home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 253 / Issue 253 - March 2009 - DPCS0309DVD.ISO / Toolkit / Internet / WinHTTrack / httrack-3.43.exe / {app} / src / htslib.c < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  158.8 KB  |  5,690 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20.  
  21. Important notes:
  22.  
  23. - We hereby ask people using this source NOT to use it in purpose of grabbing
  24. emails addresses, or collecting any other private information on persons.
  25. This would disgrace our work, and spoil the many hours we spent on it.
  26.  
  27.  
  28. Please visit our Website: http://www.httrack.com
  29. */
  30.  
  31.  
  32. /* ------------------------------------------------------------ */
  33. /* File: Subroutines                                            */
  34. /* Author: Xavier Roche                                         */
  35. /* ------------------------------------------------------------ */
  36.  
  37. /* Internal engine bytecode */
  38. #define HTS_INTERNAL_BYTECODE
  39.  
  40. // Fichier librairie .c
  41.  
  42. #include "htscore.h"
  43.  
  44. #ifdef _WIN32_WCE
  45. #ifndef HTS_CECOMPAT
  46. #pragma comment(lib, "celib.lib") //link with celib
  47. #endif
  48. #endif
  49.  
  50. /* specific definitions */
  51. #include "htsbase.h"
  52. #include "htsnet.h"
  53. #include "htsbauth.h"
  54. #include "htsthread.h"
  55. #include "htsback.h"
  56. #include "htswrap.h"
  57. #include "htsmd5.h"
  58. #include "htsmodules.h"
  59.  
  60. #ifdef _WIN32
  61. #ifndef  _WIN32_WCE
  62. #include <direct.h>
  63. #endif
  64. #else
  65. #ifdef HAVE_SYS_TYPES_H
  66. #include <sys/types.h>
  67. #endif
  68. #ifdef HAVE_SYS_STAT_H
  69. #include <sys/stat.h>
  70. #endif
  71. #ifdef HAVE_UNISTD_H
  72. #include <unistd.h>
  73. #endif
  74. #endif  /* _WIN32 */
  75.  
  76. #include <string.h>
  77. #include <time.h>
  78.  
  79. #ifndef  _WIN32_WCE
  80. #include <sys/timeb.h>
  81. #include <fcntl.h>
  82. #else
  83. #ifndef HTS_CECOMPAT
  84. #include <sys/timeb.h>
  85. #endif
  86. #endif  /* _WIN32_WCE */
  87.  
  88. // pour utimbuf
  89. #ifdef _WIN32
  90. #ifndef _WIN32_WCE
  91. #include <sys/utime.h>
  92. #else
  93. #ifndef HTS_CECOMPAT
  94. #include <sys/utime.h>
  95. #endif
  96. #endif
  97. #else
  98. #include <utime.h>
  99. #endif  /* _WIN32 */
  100.  
  101. #ifndef _WIN32_WCE
  102. #include <sys/stat.h>
  103. #endif
  104. /* END specific definitions */
  105.  
  106.  
  107. // Debugging
  108. #if _HTS_WIDE
  109. FILE* DEBUG_fp=NULL;
  110. #endif
  111.  
  112. /* variables globales */
  113. int _DEBUG_HEAD;
  114. FILE* ioinfo;
  115.  
  116. #if HTS_USEOPENSSL
  117.  SSL_CTX *openssl_ctx = NULL;
  118. #endif
  119. int IPV6_resolver = 0;
  120.  
  121. /* dΘtection complΘmentaire */
  122. const char* hts_detect[] = {
  123.   "archive",
  124.   "background",
  125.   "data",         // OBJECT
  126.   "dynsrc",
  127.   "lowsrc",
  128.   "profile",      // element META
  129.   "src",
  130.   "swurl",
  131.   "url",
  132.   "usemap",
  133.   "longdesc",     // accessibility
  134.   "xlink:href",   // xml/svg tag
  135.   ""
  136. };
  137.  
  138. /* dΘtecter dΘbut */
  139. const char* hts_detectbeg[] = {
  140.   "hotspot",      /* hotspot1=..,hotspot2=.. */
  141.   ""
  142. };
  143.  
  144. /* ne pas dΘtcter de liens dedans */
  145. const char* hts_nodetect[] = {
  146.   "accept-charset",
  147.   "accesskey",
  148.   "action",
  149.   "align",
  150.   "alt",
  151.   "axes",
  152.   "axis",
  153.   "char",
  154.   "charset",
  155.   "cite",
  156.   "class",
  157.   "classid",
  158.   "code",
  159.   "color",
  160.   "datetime",
  161.   "dir",
  162.   "enctype",
  163.   "face",
  164.   "height",
  165.   "id",
  166.   "lang",
  167.   "language",
  168.   "media",
  169.   "method",
  170.   "name",
  171.   "prompt",
  172.   "scheme",
  173.   "size",
  174.   "style",
  175.   "target",
  176.   "title",
  177.   "type",
  178.   "valign",
  179.   "version",
  180.   "width",
  181.   ""
  182. };
  183.  
  184.  
  185. /* dΘtection de mini-code javascript */
  186. /* ALSO USED: detection based on the name: onXXX="<tag>" where XXX starts with upper case letter */
  187. const char* hts_detect_js[] = {
  188.   "onAbort",
  189.   "onBlur",
  190.   "onChange",
  191.   "onClick",
  192.   "onDblClick",
  193.   "onDragDrop",
  194.   "onError",
  195.   "onFocus",
  196.   "onKeyDown",
  197.   "onKeyPress",
  198.   "onKeyUp",
  199.   "onLoad",
  200.   "onMouseDown",
  201.   "onMouseMove",
  202.   "onMouseOut",
  203.   "onMouseOver",
  204.   "onMouseUp",
  205.   "onMove",
  206.   "onReset",
  207.   "onResize",
  208.   "onSelect",
  209.   "onSubmit",
  210.   "onUnload",
  211.   "style",          /* hack for CSS code data */
  212.   ""
  213. };
  214.  
  215. const char* hts_main_mime[] = {
  216.   "application",
  217.   "audio",
  218.   "image",
  219.   "message",
  220.   "multipart",
  221.   "text",
  222.   "video",
  223.   ""
  224. };
  225.  
  226. /* dΘtection "...URL=<url>" */
  227. const char* hts_detectURL[] = {
  228.   "content",
  229.   ""
  230. };
  231.  
  232. /* tags o∙ l'URL doit Ωtre rΘΘcrite mais non capturΘe */
  233. const char* hts_detectandleave[] = {
  234.   "action",
  235.   ""
  236. };
  237.  
  238. /* ne pas renommer les types renvoyΘs (souvent types inconnus) */
  239. const char* hts_mime_keep[] = {
  240.   "application/octet-stream",
  241.   "text/plain",
  242.   ""
  243. };
  244.  
  245. /* bogus servers returns these mime types when the extension is seen within the filename */
  246. const char* hts_mime_bogus_multiple[] = {
  247.   "application/x-wais-source",  /* src (src.rpm) */
  248.   ""
  249. };
  250.  
  251. /* pas de type mime connu, mais extension connue */
  252. const char* hts_ext_dynamic[] = {
  253.   "php3",
  254.   "php",
  255.   "php4",
  256.   "php2",
  257.   "cgi",
  258.   "asp",
  259.   "jsp",
  260.   "pl",
  261.   /*"exe",*/
  262.   "cfm",
  263.   "nsf", /* lotus */
  264.   ""
  265. };
  266.  
  267. /* types MIME 
  268.    note: application/octet-stream should not be used here
  269. */
  270. const char* hts_mime[][2] = {
  271.   {"application/acad","dwg"},
  272.   {"application/arj","arj"},
  273.   {"application/clariscad","ccad"},
  274.   {"application/drafting","drw"},
  275.   {"application/dxf","dxf"},
  276.   {"application/excel","xls"},
  277.   {"application/i-deas","unv"},
  278.   {"application/iges","isg"},
  279.   {"application/iges","iges"},
  280.   {"application/mac-binhex40","hqx"},
  281.   {"application/mac-compactpro","cpt"},
  282.   {"application/msword","doc"},
  283.   {"application/msword","w6w"},
  284.   {"application/msword","word"},
  285.   {"application/mswrite","wri"},
  286.   /*{"application/octet-stream","dms"},*/
  287.   /*{"application/octet-stream","lzh"},*/
  288.   /*{"application/octet-stream","lha"},*/
  289.   /*{"application/octet-stream","bin"},*/
  290.   {"application/oda","oda"},
  291.   {"application/pdf","pdf"},
  292.   {"application/postscript","ps"},
  293.   {"application/postscript","ai"},
  294.   {"application/postscript","eps"},
  295.   {"application/powerpoint","ppt"},
  296.   {"application/pro_eng","prt"},
  297.   {"application/pro_eng","part"},
  298.   {"application/rtf","rtf"},
  299.   {"application/set","set"},
  300.   {"application/sla","stl"},
  301.   {"application/smil","smi"},
  302.   {"application/smil","smil"},
  303.   {"application/smil","sml"},
  304.   {"application/solids","sol"},
  305.   {"application/STEP","stp"},
  306.   {"application/STEP","step"},
  307.   {"application/vda","vda"},
  308.   {"application/x-authorware-map","aam"},     
  309.   {"application/x-authorware-seg","aas"},
  310.   {"application/x-authorware-bin","aab"},
  311.   {"application/x-bzip2","bz2"},
  312.   {"application/x-cocoa","cco"},
  313.   {"application/x-csh","csh"},
  314.   {"application/x-director","dir"},
  315.   {"application/x-director","dcr"},
  316.   {"application/x-director","dxr"},
  317.   {"application/x-mif","mif"},
  318.   {"application/x-dvi","dvi"},
  319.   {"application/x-gzip","gz"},
  320.   {"application/x-gzip","gzip"},
  321.   {"application/x-hdf","hdf"},
  322.   {"application/x-javascript","js"},
  323.   {"application/x-koan","skp"},
  324.   {"application/x-koan","skd"},
  325.   {"application/x-koan","skt"},
  326.   {"application/x-koan","skm"},
  327.   {"application/x-latex","latex"},
  328.   {"application/x-netcdf","nc"},
  329.   {"application/x-netcdf","cdf"},
  330.   /* {"application/x-sh","sh"}, */
  331.   /* {"application/x-csh","csh"}, */
  332.   /* {"application/x-ksh","ksh"}, */
  333.   {"application/x-shar","shar"},
  334.   {"application/x-stuffit","sit"},
  335.   {"application/x-tcl","tcl"},
  336.   {"application/x-tex","tex"},
  337.   {"application/x-texinfo","texinfo"},
  338.   {"application/x-texinfo","texi"},
  339.   {"application/x-troff","t"},
  340.   {"application/x-troff","tr"},
  341.   {"application/x-troff","roff"},
  342.   {"application/x-troff-man","man"},
  343.   {"application/x-troff-me","ms"},
  344.   {"application/x-wais-source","src"},
  345.   {"application/zip","zip"},
  346.   {"application/x-zip-compressed","zip"},
  347.   {"application/x-bcpio","bcpio"},
  348.   {"application/x-cdlink","vcd"},
  349.   {"application/x-cpio","cpio"},
  350.   {"application/x-gtar","tgz"},
  351.   {"application/x-gtar","gtar"},
  352.   {"application/x-shar","shar"},
  353.   {"application/x-shockwave-flash","swf"},
  354.   {"application/x-sv4cpio","sv4cpio"},
  355.   {"application/x-sv4crc","sv4crc"},
  356.   {"application/x-tar","tar"},
  357.   {"application/x-ustar","ustar"},
  358.   {"application/x-winhelp","hlp"},
  359.   {"application/xml","xml"},  
  360.   {"audio/midi","mid"},
  361.   {"audio/midi","midi"},
  362.   {"audio/midi","kar"},
  363.   {"audio/mpeg","mp3"},
  364.   {"audio/mpeg","mpga"},
  365.   {"audio/mpeg","mp2"},
  366.   {"audio/basic","au"},
  367.   {"audio/basic","snd"},
  368.   {"audio/x-aiff","aif"},
  369.   {"audio/x-aiff","aiff"},
  370.   {"audio/x-aiff","aifc"},
  371.   {"audio/x-pn-realaudio","rm"},
  372.   {"audio/x-pn-realaudio","ram"},
  373.   {"audio/x-pn-realaudio","ra"},
  374.   {"audio/x-pn-realaudio-plugin","rpm"},
  375.   {"audio/x-wav","wav"},
  376.   {"chemical/x-pdb","pdb"},
  377.   {"chemical/x-pdb","xyz"},
  378.   {"drawing/x-dwf","dwf"},
  379.   {"image/gif","gif"},
  380.   {"image/ief","ief"},
  381.   {"image/jpeg","jpg"},
  382.   {"image/jpeg","jpe"},
  383.   {"image/jpeg","jpeg"},
  384.   {"image/pict","pict"},
  385.   {"image/png","png"},
  386.   {"image/tiff","tiff"},
  387.   {"image/tiff","tif"},
  388.   {"image/svg+xml","svg"},
  389.   {"image/svg-xml","svg"},
  390.   {"image/x-cmu-raster","ras"},
  391.   {"image/x-freehand","fh4"},
  392.   {"image/x-freehand","fh7"},
  393.   {"image/x-freehand","fh5"},  
  394.   {"image/x-freehand","fhc"},
  395.   {"image/x-freehand","fh"},   
  396.   {"image/x-portable-anymap","pnm"},
  397.   {"image/x-portable-bitmap","pgm"},
  398.   {"image/x-portable-pixmap","ppm"},
  399.   {"image/x-rgb","rgb"},
  400.   {"image/x-xbitmap","xbm"},
  401.   {"image/x-xpixmap","xpm"},
  402.   {"image/x-xwindowdump","xwd"},
  403.   {"model/mesh","msh"},  
  404.   {"model/mesh","mesh"},  
  405.   {"model/mesh","silo"},  
  406.   {"multipart/x-zip","zip"},
  407.   {"multipart/x-gzip","gzip"},
  408.   {"text/css","css"},
  409.   {"text/html","html"},
  410.   {"text/html","htm"},
  411.   {"text/plain","txt"},
  412.   {"text/plain","g"},
  413.   {"text/plain","h"},
  414.   {"text/plain","c"},
  415.   {"text/plain","cc"},
  416.   {"text/plain","hh"},
  417.   {"text/plain","m"},
  418.   {"text/plain","f90"},
  419.   {"text/richtext","rtx"},
  420.   {"text/tab-separated-values","tsv"},
  421.   {"text/x-setext","etx"},
  422.   {"text/x-sgml","sgml"},
  423.   {"text/x-sgml","sgm"},
  424.   {"text/xml","xml"},  
  425.   {"text/xml","dtd"},  
  426.   {"video/mpeg","mpeg"},
  427.   {"video/mpeg","mpg"},
  428.   {"video/mpeg","mpe"},
  429.   {"video/quicktime","qt"},
  430.   {"video/quicktime","mov"},
  431.   {"video/x-msvideo","avi"},
  432.   {"video/x-sgi-movie","movie"},
  433.   {"x-conference/x-cooltalk","ice"},
  434.   /*{"application/x-httpd-cgi","cgi"},*/
  435.   {"x-world/x-vrml","wrl"},
  436.  
  437.   /* More from w3schools.com */
  438.   { "application/envoy", "evy" },
  439.   { "application/fractals", "fif" },
  440.   { "application/futuresplash", "spl" },
  441.   { "application/hta", "hta" },
  442.   { "application/internet-property-stream", "acx" },
  443.   { "application/msword", "dot" },
  444.   { "application/olescript", "axs" },
  445.   { "application/pics-rules", "prf" },
  446.   { "application/pkcs10", "p10" },
  447.   { "application/pkix-crl", "crl" },
  448.   { "application/set-payment-initiation", "setpay" },
  449.   { "application/set-registration-initiation", "setreg" },
  450.   { "application/vnd.ms-excel", "xls" },
  451.   { "application/vnd.ms-excel", "xla" },
  452.   { "application/vnd.ms-excel", "xlc" },
  453.   { "application/vnd.ms-excel", "xlm" },
  454.   { "application/vnd.ms-excel", "xlt" },
  455.   { "application/vnd.ms-excel", "xlw" },
  456.   { "application/vnd.ms-pkicertstore", "sst" },
  457.   { "application/vnd.ms-pkiseccat", "cat" },
  458.   { "application/vnd.ms-powerpoint", "ppt" },
  459.   { "application/vnd.ms-powerpoint", "pot" },
  460.   { "application/vnd.ms-powerpoint", "pps" },
  461.   { "application/vnd.ms-project", "mpp" },
  462.   { "application/vnd.ms-works", "wcm" },
  463.   { "application/vnd.ms-works", "wdb" },
  464.   { "application/vnd.ms-works", "wks" },
  465.   { "application/vnd.ms-works", "wps" },
  466.   { "application/x-compress", "z" },
  467.   { "application/x-compressed", "tgz" },
  468.   { "application/x-internet-signup", "ins" },
  469.   { "application/x-internet-signup", "isp" },
  470.   { "application/x-iphone", "iii" },
  471.   { "application/x-javascript", "js" },
  472.   { "application/x-msaccess", "mdb" },
  473.   { "application/x-mscardfile", "crd" },
  474.   { "application/x-msclip", "clp" },
  475.   { "application/x-msmediaview", "m13" },
  476.   { "application/x-msmediaview", "m14" },
  477.   { "application/x-msmediaview", "mvb" },
  478.   { "application/x-msmetafile", "wmf" },
  479.   { "application/x-msmoney", "mny" },
  480.   { "application/x-mspublisher", "pub" },
  481.   { "application/x-msschedule", "scd" },
  482.   { "application/x-msterminal", "trm" },
  483.   { "application/x-perfmon", "pma" },
  484.   { "application/x-perfmon", "pmc" },
  485.   { "application/x-perfmon", "pml" },
  486.   { "application/x-perfmon", "pmr" },
  487.   { "application/x-perfmon", "pmw" },
  488.   { "application/x-pkcs12", "p12" },
  489.   { "application/x-pkcs12", "pfx" },
  490.   { "application/x-pkcs7-certificates", "p7b" },
  491.   { "application/x-pkcs7-certificates", "spc" },
  492.   { "application/x-pkcs7-certreqresp", "p7r" },
  493.   { "application/x-pkcs7-mime", "p7c" },
  494.   { "application/x-pkcs7-mime", "p7m" },
  495.   { "application/x-pkcs7-signature", "p7s" },
  496.   { "application/x-troff-me", "me" },
  497.   { "application/x-x509-ca-cert", "cer" },
  498.   { "application/x-x509-ca-cert", "crt" },
  499.   { "application/x-x509-ca-cert", "der" },
  500.   { "application/ynd.ms-pkipko", "pko" },
  501.   { "audio/mid", "mid" },
  502.   { "audio/mid", "rmi" },
  503.   { "audio/mpeg", "mp3" },
  504.   { "audio/x-mpegurl", "m3u" },
  505.   { "image/bmp", "bmp" },
  506.   { "image/cis-cod", "cod" },
  507.   { "image/pipeg", "jfif" },
  508.   { "image/x-cmx", "cmx" },
  509.   { "image/x-icon", "ico" },
  510.   { "image/x-portable-bitmap", "pbm" },
  511.   { "message/rfc822", "mht" },
  512.   { "message/rfc822", "mhtml" },
  513.   { "message/rfc822", "nws" },
  514.   { "text/css", "css" },
  515.   { "text/h323", "323" },
  516.   { "text/html", "stm" },
  517.   { "text/iuls", "uls" },
  518.   { "text/plain", "bas" },
  519.   { "text/scriptlet", "sct" },
  520.   { "text/webviewhtml", "htt" },
  521.   { "text/x-component", "htc" },
  522.   { "text/x-vcard", "vcf" },
  523.   { "video/mpeg", "mp2" },
  524.   { "video/mpeg", "mpa" },
  525.   { "video/mpeg", "mpv2" },
  526.   { "video/x-la-asf", "lsf" },
  527.   { "video/x-la-asf", "lsx" },
  528.   { "video/x-ms-asf", "asf" },
  529.   { "video/x-ms-asf", "asr" },
  530.   { "video/x-ms-asf", "asx" },
  531.   { "video/x-ms-wmv", "wmv" },
  532.   { "x-world/x-vrml", "flr" },
  533.   { "x-world/x-vrml", "vrml" },
  534.   { "x-world/x-vrml", "wrz" },
  535.   { "x-world/x-vrml", "xaf" },
  536.   { "x-world/x-vrml", "xof" },
  537.  
  538.   /* Various */
  539.   { "application/ogg", "ogg" },
  540.  
  541.   {"application/x-java-vm","class"},
  542.   
  543.   {"",""}};
  544.  
  545.  
  546. // Reserved (RFC2396)
  547. #define CIS(c,ch) ( ((unsigned char)(c)) == (ch) )
  548. #define CHAR_RESERVED(c)  ( CIS(c,';') \
  549.                          || CIS(c,'/') \
  550.                          || CIS(c,'?') \
  551.                          || CIS(c,':') \
  552.                          || CIS(c,'@') \
  553.                          || CIS(c,'&') \
  554.                          || CIS(c,'=') \
  555.                          || CIS(c,'+') \
  556.                          || CIS(c,'$') \
  557.                          || CIS(c,',') )
  558. //#define CHAR_RESERVED(c)  ( strchr(";/?:@&=+$,",(unsigned char)(c)) != 0 )
  559. // Delimiters (RFC2396)
  560. #define CHAR_DELIM(c)     ( CIS(c,'<') \
  561.                          || CIS(c,'>') \
  562.                          || CIS(c,'#') \
  563.                          || CIS(c,'%') \
  564.                          || CIS(c,'\"') )
  565. //#define CHAR_DELIM(c)     ( strchr("<>#%\"",(unsigned char)(c)) != 0 )
  566. // Unwise (RFC2396)
  567. #define CHAR_UNWISE(c)    ( CIS(c,'{') \
  568.                          || CIS(c,'}') \
  569.                          || CIS(c,'|') \
  570.                          || CIS(c,'\\') \
  571.                          || CIS(c,'^') \
  572.                          || CIS(c,'[') \
  573.                          || CIS(c,']') \
  574.                          || CIS(c,'`') )
  575. //#define CHAR_UNWISE(c)    ( strchr("{}|\\^[]`",(unsigned char)(c)) != 0 )
  576. // Special (escape chars) (RFC2396 + >127 )
  577. #define CHAR_LOW(c)       ( ((unsigned char)(c) <= 31) )
  578. #define CHAR_HIG(c)       ( ((unsigned char)(c) >= 127) )
  579. #define CHAR_SPECIAL(c)   ( CHAR_LOW(c) || CHAR_HIG(c) )
  580. // We try to avoid them and encode them instead
  581. #define CHAR_XXAVOID(c)   ( CIS(c,' ') \
  582.                          || CIS(c,'*') \
  583.                          || CIS(c,'\'') \
  584.                          || CIS(c,'\"') \
  585.                          || CIS(c,'&') \
  586.                          || CIS(c,'!') )
  587. //#define CHAR_XXAVOID(c)   ( strchr(" *'\"!",(unsigned char)(c)) != 0 )
  588. #define CHAR_MARK(c)      ( CIS(c,'-') \
  589.                          || CIS(c,'_') \
  590.                          || CIS(c,'.') \
  591.                          || CIS(c,'!') \
  592.                          || CIS(c,'~') \
  593.                          || CIS(c,'*') \
  594.                          || CIS(c,'\'') \
  595.                          || CIS(c,'(') \
  596.                          || CIS(c,')') )
  597. //#define CHAR_MARK(c)      ( strchr("-_.!~*'()",(unsigned char)(c)) != 0 )
  598.  
  599.  
  600.  
  601. // conversion Θventuelle / vers antislash
  602. #ifdef _WIN32
  603. char* antislash(char *catbuff, const char* s) {
  604.   char* a;
  605.   strcpybuff(catbuff,s);
  606.   while(a=strchr(catbuff,'/')) *a='\\';
  607.   return catbuff;
  608. }
  609. #endif
  610.  
  611. #ifdef _WIN32_WCE
  612. char cwd[MAX_PATH+1] = "";
  613. #endif
  614.  
  615. // RΘcupΘration d'un fichier http sur le net.
  616. // Renvoie une adresse sur le bloc de mΘmoire, ou bien
  617. // NULL si un retour.msgeur (buffer retour.msg) est survenue. 
  618. //
  619. // Une adresse de structure htsmsg peut Ωtre transmise pour
  620. // suivre l'Θvolution du chargement si le process a ΘtΘ lancΘ 
  621. // en background
  622.  
  623. htsblk httpget(httrackp *opt,char* url) {
  624.   char BIGSTK adr[HTS_URLMAXSIZE*2];   // adresse
  625.   char BIGSTK fil[HTS_URLMAXSIZE*2];   // chemin
  626.   
  627.   // sΘparer URL en adresse+chemin
  628.   if (ident_url_absolute(url,adr,fil)==-1) {
  629.     htsblk retour;
  630.     memset(&retour, 0, sizeof(htsblk));    // effacer
  631.     // retour prΘdΘfini: erreur
  632.     retour.adr=NULL;
  633.     retour.size=0;
  634.     retour.msg[0]='\0';
  635.     retour.statuscode=STATUSCODE_INVALID;    
  636.     strcpybuff(retour.msg,"Error invalid URL");
  637.     return retour;
  638.   }
  639.   
  640.   return xhttpget(opt,adr,fil);
  641. }
  642.  
  643. // ouvre une liaison http, envoie une requΦte GET et rΘceptionne le header
  644. // retour: socket
  645. int http_fopen(httrackp *opt,char* adr,char* fil,htsblk* retour) {
  646.   //                / GET, traiter en-tΩte
  647.   return http_xfopen(opt,0,1,1,NULL,adr,fil,retour);
  648. }
  649.  
  650. // ouverture d'une liaison http, envoi d'une requΦte
  651. // mode: 0 GET  1 HEAD  [2 POST]
  652. // treat: traiter header?
  653. // waitconnect: attendre le connect()
  654. // note: dans retour, on met les params du proxy
  655. int http_xfopen(httrackp *opt,int mode,int treat,int waitconnect,char* xsend,char* adr,char* fil,htsblk* retour) {
  656.   //htsblk retour;
  657.   //int bufl=TAILLE_BUFFER;    // 8Ko de buffer
  658.   T_SOC soc=INVALID_SOCKET;
  659.   //char *p,*q;
  660.   
  661.   // retour prΘdΘfini: erreur
  662.   if (retour) {
  663.     retour->adr=NULL;
  664.     retour->size=0;
  665.     retour->msg[0]='\0';
  666.     retour->statuscode=STATUSCODE_NON_FATAL;          // a priori erreur non fatale
  667.   }
  668.  
  669. #if HDEBUG
  670.   printf("adr=%s\nfichier=%s\n",adr,fil);
  671. #endif
  672.   
  673.   // ouvrir liaison
  674. #if HDEBUG
  675.   printf("CrΘation d'une socket sur %s\n",adr);
  676. #endif
  677.  
  678. #if CNXDEBUG
  679.   printf("..newhttp\n");
  680. #endif
  681.  
  682.   /* connexion */
  683.   if (retour) {
  684.     if ( (!(retour->req.proxy.active)) 
  685.       ||
  686.       (
  687.         (strcmp(adr,"file://")==0) 
  688.         ||
  689.         (strncmp(adr,"https://", 8)==0) 
  690.       )
  691.       ) {    /* pas de proxy, ou non utilisable ici */
  692.       soc=newhttp(opt,adr,retour,-1,waitconnect);
  693.     } else {
  694.       soc=newhttp(opt, retour->req.proxy.name, retour,retour->req.proxy.port, waitconnect);  // ouvrir sur le proxy α la place
  695.     }
  696.   } else {
  697.     soc=newhttp(opt,adr,NULL,-1,waitconnect);    
  698.   }
  699.  
  700.   // copier index socket retour
  701.   if (retour) retour->soc=soc;
  702.  
  703.   /* Check for errors */
  704.   if (soc == INVALID_SOCKET) {
  705.     if (retour) {
  706.       if (retour->msg) {
  707.         if (!strnotempty(retour->msg)) {
  708. #ifdef _WIN32
  709.           int last_errno = WSAGetLastError();
  710.           sprintf(retour->msg,"Connect error: %s", strerror(last_errno));
  711. #else
  712.           int last_errno = errno;
  713.           sprintf(retour->msg,"Connect error: %s", strerror(last_errno));
  714. #endif
  715.         }
  716.       }
  717.     }
  718.   }
  719.  
  720.   // --------------------
  721.   // court-circuit (court circuite aussi le proxy..)
  722.   // LOCAL_SOCKET_ID est une pseudo-socket locale
  723.   if (soc==LOCAL_SOCKET_ID) {
  724.     retour->is_file=1;  // fichier local
  725.     if (mode==0) {    // GET
  726.  
  727.       // Test en cas de file:///C|...
  728.       if (!fexist(fconv(OPT_GET_BUFF(opt), unescape_http(OPT_GET_BUFF(opt),fil))))
  729.         if (fexist(fconv(OPT_GET_BUFF(opt), unescape_http(OPT_GET_BUFF(opt),fil+1)))) {
  730.           char BIGSTK tempo[HTS_URLMAXSIZE*2];
  731.           strcpybuff(tempo,fil+1);
  732.           strcpybuff(fil,tempo);
  733.         }
  734.  
  735.       // Ouvrir
  736.       retour->totalsize=fsize(fconv(OPT_GET_BUFF(opt), unescape_http(OPT_GET_BUFF(opt),fil)));  // taille du fichier
  737.       retour->msg[0]='\0';
  738.       soc=INVALID_SOCKET;
  739.       if (retour->totalsize<0)
  740.         strcpybuff(retour->msg,"Unable to open local file");
  741.       else if (retour->totalsize==0)
  742.         strcpybuff(retour->msg,"File empty");
  743.       else {
  744.         // Note: On passe par un FILE* (plus propre)
  745.         //soc=open(fil,O_RDONLY,0);    // en lecture seule!
  746.         retour->fp=fopen(fconv(OPT_GET_BUFF(opt), unescape_http(OPT_GET_BUFF(opt),fil)),"rb");  // ouvrir
  747.         if (retour->fp==NULL)
  748.           soc=INVALID_SOCKET;
  749.         else
  750.           soc=LOCAL_SOCKET_ID;
  751.       }
  752.       retour->soc=soc;
  753.       if (soc!=INVALID_SOCKET) {
  754.         retour->statuscode=HTTP_OK;   // OK
  755.         strcpybuff(retour->msg,"OK");
  756.         guess_httptype(opt,retour->contenttype,fil);
  757.       } else if (strnotempty(retour->msg)==0)
  758.           strcpybuff(retour->msg,"Unable to open local file");
  759.       return soc;  // renvoyer
  760.     } else {    // HEAD ou POST : interdit sur un local!!!! (c'est idiot!)
  761.       strcpybuff(retour->msg,"Unexpected Head/Post local request");
  762.       soc=INVALID_SOCKET;    // erreur
  763.       retour->soc=soc;
  764.       return soc;
  765.     }
  766.   } 
  767.   // --------------------
  768.  
  769.   if (soc!=INVALID_SOCKET) {    
  770.     char rcvd[1100];
  771.     rcvd[0]='\0';
  772. #if HDEBUG
  773.     printf("Ok, connexion rΘussie, id=%d\n",soc);
  774. #endif
  775.     
  776.     // connectΘ?
  777.     if (waitconnect) {
  778.       http_sendhead(opt,NULL,mode,xsend,adr,fil,NULL,NULL,retour);
  779.     } 
  780.     
  781.     if (soc!=INVALID_SOCKET) {
  782.       
  783. #if HDEBUG
  784.       printf("Attente de la rΘponse:\n");
  785. #endif
  786.       
  787.       // si GET (rΘception d'un fichier), rΘceptionner en-tΩte d'abord,
  788.       // et ensuite le corps
  789.       // si POST on ne rΘceptionne rien du tout, c'est aprΦs que l'on fera
  790.       // une rΘception standard pour rΘcupΘrer l'en tΩte
  791.       if ((treat) && (waitconnect)) {  // traiter (attendre!) en-tΩte        
  792.         // RΘception de la status line et de l'en-tΩte (norme RFC1945)
  793.         
  794.         // status-line α rΘcupΘrer
  795.         finput(soc,rcvd,1024);
  796.         if (strnotempty(rcvd)==0)
  797.           finput(soc,rcvd,1024);    // "certains serveurs buggΘs envoient un \n au dΘbut" (RFC)
  798.  
  799.         // traiter status-line
  800.         treatfirstline(retour,rcvd);
  801.  
  802. #if HDEBUG
  803.         printf("Status-Code=%d\n",retour->statuscode);
  804. #endif
  805.         
  806.         // en-tΩte
  807.         
  808.         // header // ** !attention! HTTP/0.9 non supportΘ
  809.         do {
  810.           finput(soc,rcvd,1024);          
  811. #if HDEBUG
  812.           printf(">%s\n",rcvd);      
  813. #endif
  814.           if (strnotempty(rcvd))
  815.             treathead(NULL,NULL,NULL,retour,rcvd);  // traiter
  816.  
  817.         } while(strnotempty(rcvd));
  818.         
  819.         //rcvsize=-1;    // forCER CHARGEMENT INCONNU
  820.         
  821.         //if (retour)
  822.         //  retour->totalsize=rcvsize;
  823.         
  824.       } else { // si GET, on recevra l'en tΩte APRES
  825.         //rcvsize=-1;    // on ne connait pas la taille de l'en-tΩte
  826.         if (retour)
  827.           retour->totalsize=-1;
  828.       }
  829.       
  830.     }
  831.  
  832.   }
  833.     
  834.   return soc;
  835. }
  836.  
  837.  
  838. // envoi d'une requΦte
  839. int http_sendhead(httrackp *opt,t_cookie* cookie,int mode,char* xsend,char* adr,char* fil,char* referer_adr,char* referer_fil,htsblk* retour) {
  840.   char BIGSTK buff[8192];
  841.   //int use_11=0;     // HTTP 1.1 utilisΘ
  842.   int direct_url=0; // ne pas analyser l'url (exemple: ftp://)
  843.   char* search_tag=NULL;
  844.   buff[0]='\0';
  845.  
  846.   // header Date
  847.   //strcatbuff(buff,"Date: ");
  848.   //time_gmt_rfc822(buff);    // obtenir l'heure au format rfc822
  849.   //sendc("\n");
  850.   //strcatbuff(buff,buff);
  851.  
  852.   // possibilitΘ non documentΘe: >post: et >postfile:
  853.   // si prΘsence d'un tag >post: alors executer un POST
  854.   // exemple: http://www.someweb.com/test.cgi?foo>post:posteddata=10&foo=5
  855.   // si prΘsence d'un tag >postfile: alors envoyer en tΩte brut contenu dans le fichier en question
  856.   // exemple: http://www.someweb.com/test.cgi?foo>postfile:post0.txt
  857.   search_tag=strstr(fil,POSTTOK":");
  858.   if (!search_tag) {
  859.     search_tag=strstr(fil,POSTTOK"file:");
  860.     if (search_tag) {     // postfile
  861.       if (mode==0) {      // GET!
  862.         FILE* fp=fopen(unescape_http(OPT_GET_BUFF(opt),search_tag+strlen(POSTTOK)+5),"rb");
  863.         if (fp) {
  864.           char BIGSTK line[1100];
  865.           char BIGSTK protocol[256],url[HTS_URLMAXSIZE*2],method[256];
  866.           linput(fp,line,1000);
  867.           if (sscanf(line,"%s %s %s",method,url,protocol) == 3) {
  868.             // selon que l'on a ou pas un proxy
  869.             if (retour->req.proxy.active)
  870.               sprintf(buff,"%s http://%s%s %s\r\n",method,adr,url,protocol);
  871.             else
  872.               sprintf(buff,"%s %s %s\r\n",method,url,protocol);
  873.             // lire le reste en brut
  874.             fread(buff+strlen(buff),8000-strlen(buff),1,fp);
  875.           }
  876.           fclose(fp);
  877.         }
  878.       }
  879.     }
  880.   }
  881.   // Fin postfile
  882.   
  883.   if (strnotempty(buff)==0) {    // PAS POSTFILE
  884.     // Type de requΦte?
  885.     if ((search_tag) && (mode==0)) {
  886.       strcatbuff(buff,"POST ");
  887.     } else if (mode==0) {    // GET
  888.       strcatbuff(buff,"GET ");
  889.     } else {  // if (mode==1) {
  890.       if (!retour->req.http11)        // forcer HTTP/1.0
  891.         strcatbuff(buff,"GET ");      // certains serveurs (cgi) buggent avec HEAD
  892.       else
  893.         strcatbuff(buff,"HEAD ");
  894.     }
  895.     
  896.     // si on gΦre un proxy, il faut une Absolute URI: on ajoute avant http://www.adr.dom
  897.     if ( retour->req.proxy.active && (strncmp(adr,"https://", 8) != 0) ) {
  898.       if (!link_has_authority(adr)) {  // default http
  899. #if HDEBUG
  900.         printf("Proxy Use: for %s%s proxy %d port %d\n",adr,fil,retour->req.proxy.name,retour->req.proxy.port);
  901. #endif
  902.         strcatbuff(buff,"http://");
  903.         strcatbuff(buff,jump_identification(adr));
  904.       } else {          // ftp:// en proxy http
  905. #if HDEBUG
  906.         printf("Proxy Use for ftp: for %s%s proxy %d port %d\n",adr,fil,retour->req.proxy.name,retour->req.proxy.port);
  907. #endif
  908.         direct_url=1;             // ne pas analyser user/pass
  909.         strcatbuff(buff,adr);
  910.       }
  911.     } 
  912.     
  913.     // NOM DU FICHIER
  914.     // on slash doit Ωtre prΘsent en dΘbut, sinon attention aux bad request! (400)
  915.     if (*fil!='/') strcatbuff(buff,"/");
  916.     {
  917.       char BIGSTK tempo[HTS_URLMAXSIZE*2];
  918.       tempo[0]='\0';
  919.       if (search_tag)
  920.         strncatbuff(tempo,fil,(int) (search_tag - fil));
  921.       else
  922.         strcpybuff(tempo,fil);
  923.       escape_check_url(tempo);
  924.       strcatbuff(buff,tempo);       // avec Θchappement
  925.     }
  926.     
  927.     // protocole
  928.     if (!retour->req.http11) {     // forcer HTTP/1.0
  929.       //use_11=0;
  930.       strcatbuff(buff," HTTP/1.0\x0d\x0a");
  931.     } else {                   // RequΦte 1.1
  932.       //use_11=1;
  933.       strcatbuff(buff," HTTP/1.1\x0d\x0a");
  934.     }
  935.  
  936.     /* supplemental data */
  937.     if (xsend) strcatbuff(buff,xsend);    // Θventuelles autres lignes
  938.  
  939.     // tester proxy authentication
  940.     if (retour->req.proxy.active) {
  941.       if (link_has_authorization(retour->req.proxy.name)) {  // et hop, authentification proxy!
  942.         const char* a = jump_identification(retour->req.proxy.name);
  943.         const char* astart = jump_protocol(retour->req.proxy.name);
  944.         char autorisation[1100];
  945.         char user_pass[256];        
  946.         autorisation[0]=user_pass[0]='\0';
  947.         //
  948.         strncatbuff(user_pass,astart,(int) (a - astart) - 1);
  949.         strcpybuff(user_pass,unescape_http(OPT_GET_BUFF(opt),user_pass));
  950.         code64((unsigned char*)user_pass,(int)strlen(user_pass),(unsigned char*)autorisation,0);
  951.         strcatbuff(buff,"Proxy-Authorization: Basic ");
  952.         strcatbuff(buff,autorisation);
  953.         strcatbuff(buff,H_CRLF);
  954. #if HDEBUG
  955.         printf("Proxy-Authenticate, %s (code: %s)\n",user_pass,autorisation);
  956. #endif
  957.       }
  958.     }
  959.     
  960.     // Referer?
  961.     if (referer_adr != NULL && referer_fil != NULL 
  962.       && strnotempty(referer_adr) && strnotempty(referer_fil)
  963.       ) {   // non vide
  964.       if (
  965.         (strcmp(referer_adr,"file://") != 0)
  966.         &&
  967.         (  /* no https referer to http urls */
  968.         (strncmp(referer_adr, "https://", 8) != 0)  /* referer is not https */
  969.         ||
  970.         (strncmp(adr, "https://", 8) == 0)          /* or referer AND addresses are https */
  971.         )
  972.         ) {      // PAS file://
  973.         strcatbuff(buff,"Referer: ");
  974.         strcatbuff(buff,"http://");
  975.         strcatbuff(buff,jump_identification(referer_adr));
  976.         strcatbuff(buff,referer_fil);
  977.         strcatbuff(buff,H_CRLF);
  978.       }
  979.     }
  980.     // HTTP field: referer
  981.     else if (retour->req.referer[0] != '\0') {
  982.       strcatbuff(buff,"Referer: ");
  983.       strcatbuff(buff, retour->req.referer);
  984.       strcatbuff(buff, H_CRLF);     
  985.     }
  986.     
  987.     // POST?
  988.     if (mode==0) {      // GET!
  989.       if (search_tag) {
  990.         char clen[256];
  991.         sprintf(clen,"Content-length: %d"H_CRLF,(int)(strlen(unescape_http(OPT_GET_BUFF(opt),search_tag+strlen(POSTTOK)+1))));
  992.         strcatbuff(buff,clen);
  993.       }
  994.     }
  995.     
  996.     // gestion cookies?
  997.     if (cookie) {
  998.             char buffer[8192];
  999.       char* b=cookie->data;
  1000.       int cook=0;
  1001.       int max_cookies=8;
  1002.       size_t max_size=2048;
  1003.       max_size+=strlen(buff);
  1004.       do {
  1005.         b=cookie_find(b,"",jump_identification(adr),fil);       // prochain cookie satisfaisant aux conditions
  1006.         if (b) {
  1007.           max_cookies--;
  1008.           if (!cook) {
  1009.             strcatbuff(buff,"Cookie: ");
  1010.             strcatbuff(buff,"$Version=1; ");
  1011.             cook=1;
  1012.           } else
  1013.             strcatbuff(buff,"; ");
  1014.           strcatbuff(buff,cookie_get(buffer,b,5));
  1015.           strcatbuff(buff,"=");
  1016.           strcatbuff(buff,cookie_get(buffer,b,6));
  1017.           strcatbuff(buff,"; $Path=");
  1018.           strcatbuff(buff,cookie_get(buffer,b,2));
  1019.           b=cookie_nextfield(b);
  1020.         }
  1021.       } while( (b) && (max_cookies>0) && ((int)strlen(buff)<max_size));
  1022.       if (cook) {                           // on a envoyΘ un (ou plusieurs) cookie?
  1023.         strcatbuff(buff,H_CRLF);
  1024. #if DEBUG_COOK
  1025.         printf("Header:\n%s\n",buff);
  1026. #endif
  1027.       }
  1028.     }
  1029.     
  1030.     // gΘrer le keep-alive (garder socket)
  1031.     if (retour->req.http11 && !retour->req.nokeepalive) {
  1032.             strcatbuff(buff,"Connection: Keep-Alive"H_CRLF);
  1033.         } else {
  1034.       strcatbuff(buff,"Connection: close"H_CRLF);
  1035.         }
  1036.     
  1037.     {
  1038.       char* real_adr=jump_identification(adr);
  1039.       //if ((use_11) || (retour->user_agent_send)) {   // Pour le 1.1 on utilise un Host:
  1040.       if (!direct_url) {     // pas ftp:// par exemple
  1041.         //if (!retour->req.proxy.active) {
  1042.         strcatbuff(buff,"Host: "); strcatbuff(buff,real_adr); strcatbuff(buff,H_CRLF);
  1043.         //}
  1044.       }
  1045.       //}
  1046.  
  1047.       // HTTP field: from
  1048.       if (retour->req.from[0] != '\0') {  // HTTP from
  1049.         strcatbuff(buff,"From: ");
  1050.         strcatbuff(buff, retour->req.from);
  1051.         strcatbuff(buff, H_CRLF);
  1052.       }
  1053.  
  1054.       // PrΘsence d'un user-agent?
  1055.       if (retour->req.user_agent_send) {  // ohh un user-agent
  1056.         char s[256];
  1057.         // HyperTextSeeker/"HTSVERSION
  1058.         sprintf(s,"User-Agent: %s"H_CRLF,retour->req.user_agent);
  1059.         strcatbuff(buff,s);
  1060.         
  1061.         // pour les serveurs difficiles
  1062.         strcatbuff(buff,"Accept: "
  1063.                         "image/png, image/jpeg, image/pjpeg, image/x-xbitmap, image/svg+xml"  /* Accepted */
  1064.                         ", "
  1065.                         "image/gif;q=0.9"  /* also accepted but with lower preference */
  1066.                         ", "
  1067.                         "*/*;q=0.1"        /* also accepted but with even lower preference */
  1068.                         H_CRLF);
  1069.         if (strnotempty(retour->req.lang_iso)) {
  1070.           strcatbuff(buff,"Accept-Language: "); strcatbuff(buff,retour->req.lang_iso); strcatbuff(buff,H_CRLF);
  1071.         }
  1072.         strcatbuff(buff,"Accept-Charset: "
  1073.                         "iso-8859-1"       /* we prefer ISO-8859-1 */
  1074.                         ", "
  1075.                         "iso-8859-*;q=0.9" /* or ISO-8859-* */
  1076.                         ", "
  1077.                         "utf-8;q=0.66"     /* UTF8 is also accepted */
  1078.                         ", "
  1079.                         "*;q=0.33"         /* and any other charset */
  1080.                         H_CRLF);   
  1081.         if (retour->req.http11) {
  1082. #if HTS_USEZLIB
  1083.           //strcatbuff(buff,"Accept-Encoding: gzip, deflate, compress, identity"H_CRLF);
  1084.           if (gz_is_available && (!retour->req.range_used) && (!retour->req.nocompression))
  1085.             strcatbuff(buff,"Accept-Encoding: "
  1086.                             "gzip"         /* gzip if the preffered encoding */
  1087.                             ", "
  1088.                             "identity;q=0.9"
  1089.                             H_CRLF);
  1090.           else
  1091.             strcatbuff(buff,"Accept-Encoding: identity"H_CRLF);       /* no compression */
  1092. #else
  1093.           strcatbuff(buff,"Accept-Encoding: identity"H_CRLF);         /* no compression */
  1094. #endif
  1095.         }
  1096.       } else {
  1097.         strcatbuff(buff,"Accept: */*"H_CRLF);         // le minimum
  1098.       }
  1099.  
  1100.       /* Authentification */
  1101.       {
  1102.         char autorisation[1100];
  1103.         char* a;
  1104.         autorisation[0]='\0';
  1105.         if (link_has_authorization(adr)) {  // ohh une authentification!
  1106.           char* a=jump_identification(adr);
  1107.           char* astart=jump_protocol(adr);
  1108.           if (!direct_url) {      // pas ftp:// par exemple
  1109.             char user_pass[256];
  1110.             user_pass[0]='\0';
  1111.             strncatbuff(user_pass,astart,(int) (a - astart) - 1);
  1112.             strcpybuff(user_pass,unescape_http(OPT_GET_BUFF(opt),user_pass));
  1113.             code64((unsigned char*)user_pass,(int)strlen(user_pass),(unsigned char*)autorisation,0);
  1114.             if (strcmp(fil,"/robots.txt"))      /* pas robots.txt */
  1115.               bauth_add(cookie,astart,fil,autorisation);
  1116.           }
  1117.         } else if ( (a=bauth_check(cookie,real_adr,fil)) )
  1118.           strcpybuff(autorisation,a);
  1119.         /* On a une autorisation a donner?  */
  1120.         if (strnotempty(autorisation)) {
  1121.           strcatbuff(buff,"Authorization: Basic ");
  1122.           strcatbuff(buff,autorisation);
  1123.           strcatbuff(buff,H_CRLF);
  1124.         }
  1125.       }
  1126.  
  1127.     }
  1128.     //strcatbuff(buff,"Accept-Language: en\n");
  1129.     //strcatbuff(buff,"Accept-Charset: iso-8859-1,*,utf-8\n");
  1130.     
  1131.     // CRLF de fin d'en tΩte
  1132.     strcatbuff(buff,H_CRLF);
  1133.     
  1134.     // donnΘes complΘmentaires?
  1135.     if (search_tag)
  1136.     if (mode==0)      // GET!
  1137.       strcatbuff(buff,unescape_http(OPT_GET_BUFF(opt),search_tag+strlen(POSTTOK)+1));
  1138.   }
  1139.   
  1140. #if HDEBUG
  1141. #endif
  1142.   if (_DEBUG_HEAD) {
  1143.     if (ioinfo) {
  1144.       fprintf(ioinfo,"[%d] request for %s%s:\r\n",retour->debugid,jump_identification(adr),fil);
  1145.       fprintfio(ioinfo,buff,"<<< ");
  1146.       fprintf(ioinfo,"\r\n");
  1147.       fflush(ioinfo);
  1148.     }
  1149.   }  // Fin test pas postfile
  1150.   //
  1151.  
  1152.   // Callback
  1153.   {
  1154.     int test_head = RUN_CALLBACK6(opt, sendhead, buff, adr, fil, referer_adr, referer_fil, retour);
  1155.     if (test_head!=1) {
  1156.       deletesoc_r(retour);
  1157.       strcpybuff(retour->msg,"Header refused by external wrapper");
  1158.       retour->soc=INVALID_SOCKET;
  1159.     }
  1160.   }
  1161.  
  1162.   // Envoi
  1163.   HTS_STAT.last_request = mtime_local();
  1164.   if (sendc(retour, buff)<0) {  // ERREUR, socket rompue?...
  1165.   //if (sendc(retour->soc,buff) != strlen(buff)) {  // ERREUR, socket rompue?...
  1166.     deletesoc_r(retour);  // fermer tout de mΩme
  1167.     // et tenter de reconnecter
  1168.     
  1169.     strcpybuff(retour->msg, "Write error");
  1170.     retour->soc=INVALID_SOCKET;
  1171.   }
  1172.   
  1173.   // RX'98
  1174.   return 0;
  1175. }
  1176.  
  1177.  
  1178.  
  1179.  
  1180. // traiter 1ere ligne d'en tΩte
  1181. void treatfirstline(htsblk* retour,char* rcvd) {
  1182.   char* a=rcvd;
  1183.   // exemple:
  1184.   // HTTP/1.0 200 OK
  1185.   if (*a) {
  1186.     // note: certains serveurs buggΘs renvoient HTTP/1.0\n200 OK ou " HTTP/1.0 200 OK"
  1187.     while ((*a==' ') || (*a==10) || (*a==13) || (*a==9)) a++;      // Θpurer espaces au dΘbut
  1188.     if (strfield(a, "HTTP/")) {
  1189.       // sauter HTTP/1.x
  1190.       while ((*a!=' ') && (*a!='\0') && (*a!=10) && (*a!=13) && (*a!=9)) a++;   
  1191.       if (*a != '\0') {
  1192.         while ((*a==' ') || (*a==10) || (*a==13) || (*a==9)) a++;      // Θpurer espaces
  1193.         if ((*a>='0') && (*a<='9')) {
  1194.           sscanf(a,"%d",&(retour->statuscode));
  1195.           // sauter 200
  1196.           while ((*a!=' ') && (*a!='\0') && (*a!=10) && (*a!=13) && (*a!=9)) a++;   
  1197.           while ((*a==' ') || (*a==10) || (*a==13) || (*a==9)) a++;      // Θpurer espaces
  1198.           if ((strlen(a) > 1) && (strlen(a) < 64) )                // message retour
  1199.             strcpybuff(retour->msg,a);
  1200.           else
  1201.             infostatuscode(retour->msg,retour->statuscode);
  1202.           // type MIME par dΘfaut2
  1203.           strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  1204.         } else {  // pas de code!
  1205.           retour->statuscode=STATUSCODE_INVALID;
  1206.           strcpybuff(retour->msg,"Unknown response structure");
  1207.         }
  1208.       } else {  // euhh??
  1209.         retour->statuscode=STATUSCODE_INVALID;
  1210.         strcpybuff(retour->msg,"Unknown response structure");
  1211.       }
  1212.     } else {
  1213.             if (*a == '<') {
  1214.         /* This is dirty .. */
  1215.         retour->statuscode=HTTP_OK;
  1216.         retour->keep_alive=0;
  1217.         strcpybuff(retour->msg, "Unknown, assuming junky server");
  1218.         strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  1219.             } else if (strnotempty(a)) {
  1220.         retour->statuscode=STATUSCODE_INVALID;
  1221.         strcpybuff(retour->msg,"Unknown (not HTTP/xx) response structure");
  1222.       } else {
  1223.         /* This is dirty .. */
  1224.         retour->statuscode=HTTP_OK;
  1225.         retour->keep_alive=0;
  1226.         strcpybuff(retour->msg, "Unknown, assuming junky server");
  1227.         strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  1228.       }
  1229.     }
  1230.   } else {  // vide!
  1231.     /*
  1232.     retour->statuscode=STATUSCODE_INVALID;
  1233.     strcpybuff(retour->msg,"Empty reponse or internal error");
  1234.     */
  1235.     /* This is dirty .. */
  1236.     retour->statuscode=HTTP_OK;
  1237.     strcpybuff(retour->msg, "Unknown, assuming junky server");
  1238.     strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  1239.   }
  1240. }
  1241.  
  1242. // traiter ligne par ligne l'en tΩte
  1243. // gestion des cookies
  1244. void treathead(t_cookie* cookie,char* adr,char* fil,htsblk* retour,char* rcvd) {
  1245.   int p;
  1246.   if ((p=strfield(rcvd,"Content-length:"))!=0) {
  1247. #if HDEBUG
  1248.     printf("ok, Content-length: dΘtectΘ\n");
  1249. #endif
  1250.     sscanf(rcvd+p,LLintP,&(retour->totalsize));
  1251.     if (retour->totalsize == 0) {
  1252.       retour->empty = 1;
  1253.     }
  1254.   }
  1255.   else if ((p=strfield(rcvd,"Content-Disposition:"))!=0) {
  1256.     while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1257.     if ((int) strlen(rcvd+p)<250) { // pas trop long?
  1258.       char tmp[256];
  1259.       char *a=NULL,*b=NULL;
  1260.       strcpybuff(tmp,rcvd+p);
  1261.       a=strstr(tmp,"filename=");
  1262.       if (a) {
  1263.         a+=strlen("filename=");
  1264.         while(is_space(*a)) a++;
  1265.         //a=strchr(a,'"');
  1266.         if (a) {
  1267.           char *c=NULL;
  1268.           //a++;      /* jump " */
  1269.           while((c=strchr(a,'/')))    /* skip all / (see RFC2616) */
  1270.             a=c+1;
  1271.           //b=strchr(a+1,'"');
  1272.           b=a+strlen(a)-1;
  1273.           while(is_space(*b)) b--;
  1274.           b++;
  1275.           if (b) {
  1276.             *b='\0';
  1277.             if ((int) strlen(a) < 200) { // pas trop long?
  1278.               strcpybuff(retour->cdispo,a);
  1279.             }
  1280.           }
  1281.         }
  1282.       } 
  1283.     }
  1284.   }
  1285.   else if ((p=strfield(rcvd,"Last-Modified:"))!=0) {
  1286.     while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1287.     if ((int) strlen(rcvd+p)<64) { // pas trop long?
  1288.       //struct tm* tm_time=convert_time_rfc822(rcvd+p);
  1289.       strcpybuff(retour->lastmodified,rcvd+p);
  1290.     }
  1291.   }
  1292.   else if ((p=strfield(rcvd,"Date:"))!=0) {
  1293.     if (strnotempty(retour->lastmodified)==0) {          /* pas encore de last-modified */
  1294.       while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1295.       if ((int) strlen(rcvd+p)<64) { // pas trop long?
  1296.         //struct tm* tm_time=convert_time_rfc822(rcvd+p);
  1297.         strcpybuff(retour->lastmodified,rcvd+p);
  1298.       }
  1299.     }
  1300.   }
  1301.   else if ((p=strfield(rcvd,"Etag:"))!=0) {   /* Etag */
  1302.     if (retour) {
  1303.       while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1304.       if ((int) strlen(rcvd+p)<64)  // pas trop long?
  1305.         strcpybuff(retour->etag,rcvd+p);
  1306.       else    // erreur.. ignorer
  1307.         retour->etag[0]='\0';
  1308.     }
  1309.   }
  1310.   // else if ((p=strfield(rcvd,"Transfer-Encoding: chunked"))!=0) {  // chunk!
  1311.   else if ((p=strfield(rcvd,"Transfer-Encoding:"))!=0) {  // chunk!
  1312.     while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1313.     if (strfield(rcvd+p,"chunked")) {
  1314.       retour->is_chunk=1;     // chunked
  1315.       //retour->http11=2;     // chunked
  1316. #if HDEBUG
  1317.       printf("ok, Transfer-Encoding: dΘtectΘ\n");
  1318. #endif
  1319.     }
  1320.   }
  1321.   else if ((p=strfield(rcvd,"Content-type:"))!=0) {
  1322.     if (retour) {
  1323.       char tempo[1100];
  1324.       // Θviter les text/html; charset=foo
  1325.       {
  1326.         char* a=strchr(rcvd+p,';');
  1327.         if (a) {   // extended information
  1328.           *a='\0';
  1329.           a++;
  1330.               while(is_space(*a)) a++;
  1331.           if (strfield(a, "charset")) {
  1332.             a += 7;
  1333.                 while(is_space(*a)) a++;
  1334.             if (*a == '=') {
  1335.               a++;
  1336.                   while(is_space(*a)) a++;
  1337.               if (*a == '\"') a++;
  1338.                   while(is_space(*a)) a++;
  1339.               if (*a) {
  1340.                 char* chs = a;
  1341.                 while(*a && !is_space(*a) && *a != '\"' && *a != ';') a++;
  1342.                 *a = '\0';
  1343.                 if (*chs) {
  1344.                   if (strlen(chs) < sizeof(retour->charset) - 2) {
  1345.                     strcpybuff(retour->charset, chs);
  1346.                   }
  1347.                 }
  1348.               }
  1349.             }
  1350.           }
  1351.         }
  1352.       }
  1353.       sscanf(rcvd+p,"%s",tempo);
  1354.       if (strlen(tempo) < sizeof(retour->contenttype) - 2)    // pas trop long!!
  1355.         strcpybuff(retour->contenttype,tempo);
  1356.       else
  1357.         strcpybuff(retour->contenttype,"application/octet-stream-unknown");    // erreur
  1358.     }
  1359.   }
  1360.   else if ((p=strfield(rcvd,"Content-Range:"))!=0) {
  1361.     char* a=strstr(rcvd+p,"*/");
  1362.     if (a) {
  1363.       if (sscanf(a+2,LLintP,&retour->crange) != 1) {
  1364.         retour->crange=0;
  1365.       }
  1366.     }
  1367.   }
  1368.   else if ((p=strfield(rcvd,"Connection:"))!=0) {
  1369.         char* a = rcvd + p;
  1370.         while(is_space(*a)) a++;
  1371.         if (*a) {
  1372.             if (strfield(a, "Keep-Alive")) {
  1373.         if (!retour->keep_alive) {
  1374.           retour->keep_alive_max = 10;
  1375.           retour->keep_alive_t = 15;
  1376.         }
  1377.         retour->keep_alive = 1;
  1378.       } else {
  1379.                 retour->keep_alive = 0;
  1380.       }
  1381.         }
  1382.     }
  1383.   else if ((p=strfield(rcvd,"Keep-Alive:"))!=0) {
  1384.         char* a = rcvd + p;
  1385.         while(is_space(*a)) a++;
  1386.         if (*a) {
  1387.       char* p;
  1388.       retour->keep_alive = 1;
  1389.       retour->keep_alive_max = 10;
  1390.       retour->keep_alive_t = 15;
  1391.       if ((p=strstr(a, "timeout="))) {
  1392.         p+=strlen("timeout=");
  1393.         sscanf(p, "%d", &retour->keep_alive_t);
  1394.       }
  1395.       if ((p=strstr(a, "max="))) {
  1396.         p+=strlen("max=");
  1397.         sscanf(p, "%d", &retour->keep_alive_max);
  1398.       }
  1399.       if (retour->keep_alive_max <= 1 || retour->keep_alive_t < 3) {
  1400.         retour->keep_alive = 0;
  1401.       }
  1402.     }
  1403.   }
  1404.   else if ((p=strfield(rcvd,"TE:"))!=0) {
  1405.         char* a = rcvd + p;
  1406.         while(is_space(*a)) a++;
  1407.         if (*a) {
  1408.       if (strfield(a, "trailers")) {
  1409.         retour->keep_alive_trailers=1;
  1410.       }
  1411.     }
  1412.   }
  1413.     else if ((p=strfield(rcvd,"Content-Encoding:"))!=0) {
  1414.         if (retour) {
  1415.             char tempo[1100];
  1416.       char* a = rcvd + p;
  1417.       while(is_space(*a)) a++;
  1418.             {
  1419.                 char* a=strchr(rcvd+p,';');
  1420.                 if (a) *a='\0';
  1421.             }
  1422.             sscanf(a,"%s",tempo);
  1423.       if (strlen(tempo)<64)    // pas trop long!!
  1424.         strcpybuff(retour->contentencoding,tempo);
  1425.       else
  1426.         retour->contentencoding[0]='\0';    // erreur
  1427. #if HTS_USEZLIB
  1428.       /* Check known encodings */
  1429.       if (retour->contentencoding[0]) {
  1430.         if (
  1431.           (strfield2(retour->contentencoding, "gzip"))
  1432.           || (strfield2(retour->contentencoding, "x-gzip"))
  1433.           /*
  1434.           || (strfield2(retour->contentencoding, "compress"))
  1435.           || (strfield2(retour->contentencoding, "x-compress"))
  1436.           */
  1437.           || (strfield2(retour->contentencoding, "deflate"))
  1438.           || (strfield2(retour->contentencoding, "x-deflate"))
  1439.           ) {
  1440.         retour->compressed=1;
  1441.         }
  1442.       }
  1443. #endif
  1444.     }
  1445.   }
  1446.   else if ((p=strfield(rcvd,"Location:"))!=0) {
  1447.     if (retour) {
  1448.       if (retour->location) {
  1449.         while(is_realspace(*(rcvd+p))) p++;    // sauter espaces
  1450.         if ((int) strlen(rcvd+p)<HTS_URLMAXSIZE)  // pas trop long?
  1451.           strcpybuff(retour->location,rcvd+p);
  1452.         else    // erreur.. ignorer
  1453.           retour->location[0]='\0';
  1454.       }
  1455.     }
  1456.   }
  1457.   else if ( ((p=strfield(rcvd,"Set-Cookie:"))!=0) && (cookie) ) {    // ohh un cookie
  1458.     char* a = rcvd+p;           // pointeur
  1459.     char domain[256];           // domaine cookie (.netscape.com)
  1460.     char path[256];             // chemin (/)
  1461.     char cook_name[256];        // nom cookie (MYCOOK)
  1462.     char BIGSTK cook_value[8192];      // valeur (ID=toto,S=1234)
  1463. #if DEBUG_COOK
  1464.     printf("set-cookie detected\n");
  1465. #endif
  1466.     while(*a) {
  1467.       char *token_st,*token_end;
  1468.       char *value_st,*value_end;
  1469.       char name[256];
  1470.       char BIGSTK value[8192];
  1471.       int next=0;
  1472.       name[0]=value[0]='\0';
  1473.       //
  1474.  
  1475.       // initialiser cookie lu actuellement
  1476.       if (adr)
  1477.         strcpybuff(domain,jump_identification(adr));     // domaine
  1478.       strcpybuff(path,"/");         // chemin (/)
  1479.       strcpybuff(cook_name,"");     // nom cookie (MYCOOK)
  1480.       strcpybuff(cook_value,"");    // valeur (ID=toto,S=1234)
  1481.       // boucler jusqu'au prochain cookie ou la fin
  1482.       do {
  1483.         char* start_loop=a;
  1484.         while(is_space(*a)) a++;    // sauter espaces
  1485.         token_st=a;                 // dΘpart token
  1486.         while((!is_space(*a)) && (*a) && (*a!=';') && (*a!='=')) a++;    // arrΩter si espace, point virgule
  1487.         token_end=a;
  1488.         while(is_space(*a)) a++;    // sauter espaces
  1489.         if (*a=='=') {    // name=value
  1490.           a++;
  1491.           while(is_space(*a)) a++;    // sauter espaces
  1492.           value_st=a;
  1493.           while( (*a!=';') && (*a)) a++;    // prochain ;
  1494.           //while( ((*a!='"') || (*(a-1)=='\\')) && (*a)) a++;    // prochain " (et pas \")
  1495.           value_end=a;
  1496.           //if (*a==';') {  // finit par un ;
  1497.           // vΘrifier dΘbordements
  1498.           if ( (((int) (token_end - token_st))<200) && (((int) (value_end - value_st))<8000)
  1499.             && (((int) (token_end - token_st))>0)   && (((int) (value_end - value_st))>0) ) 
  1500.           {
  1501.             int name_len = (int) (token_end - token_st);
  1502.             int value_len = (int) (value_end - value_st);
  1503.             name[0]='\0';
  1504.             value[0]='\0';
  1505.             strncatbuff(name,token_st,name_len);
  1506.             strncatbuff(value,value_st,value_len);
  1507. #if DEBUG_COOK
  1508.             printf("detected cookie-av: name=\"%s\" value=\"%s\"\n",name,value);
  1509. #endif
  1510.             if (strfield2(name,"domain")) {
  1511.               if (value_len < sizeof(domain) - 1) {
  1512.                 strcpybuff(domain,value);
  1513.               } else {
  1514.                 cook_name[0] = 0;
  1515.                 break;
  1516.               }
  1517.             }
  1518.             else if (strfield2(name,"path")) {
  1519.               if (value_len < sizeof(path) - 1) {
  1520.                 strcpybuff(path,value);
  1521.               } else {
  1522.                 cook_name[0] = 0;
  1523.                 break;
  1524.               }
  1525.             }
  1526.             else if (strfield2(name,"max-age")) {
  1527.               // ignorΘ..
  1528.             }
  1529.             else if (strfield2(name,"expires")) {
  1530.               // ignorΘ..
  1531.             }
  1532.             else if (strfield2(name,"version")) {
  1533.               // ignorΘ..
  1534.             }
  1535.             else if (strfield2(name,"comment")) {
  1536.               // ignorΘ
  1537.             }
  1538.             else if (strfield2(name,"secure")) {    // ne devrait pas arriver ici
  1539.               // ignorΘ
  1540.             }
  1541.             else {
  1542.               if (value_len < sizeof(cook_value) - 1 && name_len < sizeof(cook_name) - 1) {
  1543.                 if (strnotempty(cook_name)==0) {          // noter premier: nom et valeur cookie
  1544.                   strcpybuff(cook_name,name);
  1545.                   strcpybuff(cook_value,value);
  1546.                 } else {                             // prochain cookie
  1547.                   a=start_loop;      // on devra recommencer α cette position
  1548.                   next=1;            // enregistrer
  1549.                 }
  1550.               } else {
  1551.                 cook_name[0] = 0;
  1552.                 break;
  1553.               }
  1554.             }
  1555.           }
  1556.         }
  1557.         if (!next) {
  1558.           while((*a!=';') && (*a)) a++;    // prochain
  1559.           while(*a==';') a++;             // sauter ;
  1560.         }
  1561.       } while((*a) && (!next));
  1562.       if (strnotempty(cook_name)) {          // cookie?
  1563. #if DEBUG_COOK
  1564.         printf("new cookie: name=\"%s\" value=\"%s\" domain=\"%s\" path=\"%s\"\n",cook_name,cook_value,domain,path);
  1565. #endif
  1566.         cookie_add(cookie,cook_name,cook_value,domain,path);
  1567.       }
  1568.     }
  1569.   }
  1570. }
  1571.  
  1572.  
  1573. // transforme le message statuscode en chaεne
  1574. HTSEXT_API void infostatuscode(char* msg,int statuscode) {
  1575.   switch( statuscode) {    
  1576.     // Erreurs HTTP, selon RFC
  1577.   case 100: strcpybuff( msg,"Continue"); break; 
  1578.   case 101: strcpybuff( msg,"Switching Protocols"); break; 
  1579.   case 200: strcpybuff( msg,"OK"); break; 
  1580.   case 201: strcpybuff( msg,"Created"); break; 
  1581.   case 202: strcpybuff( msg,"Accepted"); break; 
  1582.   case 203: strcpybuff( msg,"Non-Authoritative Information"); break; 
  1583.   case 204: strcpybuff( msg,"No Content"); break; 
  1584.   case 205: strcpybuff( msg,"Reset Content"); break; 
  1585.   case 206: strcpybuff( msg,"Partial Content"); break; 
  1586.   case 300: strcpybuff( msg,"Multiple Choices"); break; 
  1587.   case 301: strcpybuff( msg,"Moved Permanently"); break; 
  1588.   case 302: strcpybuff( msg,"Moved Temporarily"); break; 
  1589.   case 303: strcpybuff( msg,"See Other"); break; 
  1590.   case 304: strcpybuff( msg,"Not Modified"); break; 
  1591.   case 305: strcpybuff( msg,"Use Proxy"); break; 
  1592.   case 306: strcpybuff( msg,"Undefined 306 error"); break; 
  1593.   case 307: strcpybuff( msg,"Temporary Redirect"); break; 
  1594.   case 400: strcpybuff( msg,"Bad Request"); break; 
  1595.   case 401: strcpybuff( msg,"Unauthorized"); break; 
  1596.   case 402: strcpybuff( msg,"Payment Required"); break; 
  1597.   case 403: strcpybuff( msg,"Forbidden"); break; 
  1598.   case 404: strcpybuff( msg,"Not Found"); break; 
  1599.   case 405: strcpybuff( msg,"Method Not Allowed"); break; 
  1600.   case 406: strcpybuff( msg,"Not Acceptable"); break; 
  1601.   case 407: strcpybuff( msg,"Proxy Authentication Required"); break; 
  1602.   case 408: strcpybuff( msg,"Request Time-out"); break; 
  1603.   case 409: strcpybuff( msg,"Conflict"); break; 
  1604.   case 410: strcpybuff( msg,"Gone"); break; 
  1605.   case 411: strcpybuff( msg,"Length Required"); break; 
  1606.   case 412: strcpybuff( msg,"Precondition Failed"); break; 
  1607.   case 413: strcpybuff( msg,"Request Entity Too Large"); break; 
  1608.   case 414: strcpybuff( msg,"Request-URI Too Large"); break; 
  1609.   case 415: strcpybuff( msg,"Unsupported Media Type"); break; 
  1610.   case 416: strcpybuff( msg,"Requested Range Not Satisfiable"); break; 
  1611.   case 417: strcpybuff( msg,"Expectation Failed"); break; 
  1612.   case 500: strcpybuff( msg,"Internal Server Error"); break; 
  1613.   case 501: strcpybuff( msg,"Not Implemented"); break; 
  1614.   case 502: strcpybuff( msg,"Bad Gateway"); break; 
  1615.   case 503: strcpybuff( msg,"Service Unavailable"); break; 
  1616.   case 504: strcpybuff( msg,"Gateway Time-out"); break; 
  1617.   case 505: strcpybuff( msg,"HTTP Version Not Supported"); break; 
  1618.     //
  1619.   default: if (strnotempty(msg)==0) strcpybuff( msg,"Unknown error"); break;
  1620.   }
  1621. }
  1622.  
  1623.  
  1624. // identique au prΘcΘdent, sauf que l'on donne adr+fil et non url complΦte
  1625. htsblk xhttpget(httrackp *opt,char* adr,char* fil) {
  1626.   T_SOC soc;
  1627.   htsblk retour;
  1628.   
  1629.   memset(&retour, 0, sizeof(htsblk));
  1630.   soc=http_fopen(opt,adr,fil,&retour);
  1631.  
  1632.   if (soc!=INVALID_SOCKET) {
  1633.     http_fread(soc,&retour);
  1634. #if HTS_DEBUG_CLOSESOCK
  1635.     DEBUG_W("xhttpget: deletehttp\n");
  1636. #endif
  1637.     if (retour.soc!=INVALID_SOCKET) deletehttp(&retour);  // fermer
  1638.     retour.soc=INVALID_SOCKET;
  1639.   }
  1640.   return retour;
  1641. }
  1642.  
  1643. // variation sur un thΦme...
  1644. // rΘceptionne uniquement un en-tΩte (HEAD)
  1645. // retourne dans xx.adr l'adresse pointant sur le bloc de mΘmoire de l'en tΩte
  1646. htsblk http_gethead(httrackp *opt,char* adr,char* fil) {
  1647.   T_SOC soc;
  1648.   htsblk retour;
  1649.  
  1650.   memset(&retour, 0, sizeof(htsblk));
  1651.   soc=http_xfopen(opt,1,0,1,NULL,adr,fil,&retour);  // HEAD, pas de traitement en-tΩte
  1652.  
  1653.   if (soc!=INVALID_SOCKET) {
  1654.     http_fread(soc,&retour);    // rΘception en-tΩte
  1655. #if HTS_DEBUG_CLOSESOCK
  1656.     DEBUG_W("http_gethead: deletehttp\n");
  1657. #endif
  1658.     if (retour.soc!=INVALID_SOCKET) deletehttp(&retour);  // fermer
  1659.     retour.soc=INVALID_SOCKET;
  1660.   }
  1661.   return retour;
  1662. }
  1663. // oui ca ressemble vachement α xhttpget - en Θtant sobre on peut voir LA diffΘrence..
  1664.  
  1665.  
  1666. // lecture sur une socket ouverte, le header a dΘja ΘtΘ envoyΘ dans le cas de GET
  1667. // il ne reste plus qu'α lire les donnΘes
  1668. // (pour HEAD le header est lu ici!)
  1669. void http_fread(T_SOC soc,htsblk* retour) {  
  1670.   //int bufl=TAILLE_BUFFER;    // 8Ko de buffer
  1671.   
  1672.   if (retour) retour->soc=soc;
  1673.   if (soc!=INVALID_SOCKET) {    
  1674.     // fonction de lecture d'une socket (plus propre)
  1675.     while(http_fread1(retour)!=-1);
  1676.     soc=retour->soc;
  1677.     if (retour->adr==NULL) {
  1678.       if (strnotempty(retour->msg)==0)
  1679.         sprintf(retour->msg,"Unable to read");
  1680.       return ;    // erreur
  1681.     } 
  1682.     
  1683. #if HDEBUG
  1684.     printf("Ok, donnΘes reτues\n");
  1685. #endif   
  1686.  
  1687.     return ;
  1688.     
  1689.   } 
  1690.   
  1691.   return ;
  1692. }
  1693.  
  1694. // check if data is available
  1695. int check_readinput(htsblk* r) {
  1696.   if (r->soc != INVALID_SOCKET) {
  1697.     fd_set fds;           // poll structures
  1698.     struct timeval tv;          // structure for select
  1699.     FD_ZERO(&fds);
  1700.     FD_SET(r->soc,&fds);           
  1701.     tv.tv_sec=0;
  1702.     tv.tv_usec=0;
  1703.     select(r->soc + 1,&fds,NULL,NULL,&tv);
  1704.     if (FD_ISSET(r->soc,&fds))
  1705.       return 1;
  1706.     else
  1707.       return 0;
  1708.   } else
  1709.     return 0;
  1710. }
  1711.  
  1712. // check if data is available
  1713. int check_readinput_t(T_SOC soc, int timeout) {
  1714.   if (soc != INVALID_SOCKET) {
  1715.     fd_set fds;           // poll structures
  1716.     struct timeval tv;          // structure for select
  1717.     FD_ZERO(&fds);
  1718.     FD_SET(soc,&fds);           
  1719.     tv.tv_sec=timeout;
  1720.     tv.tv_usec=0;
  1721.     select(soc + 1,&fds,NULL,NULL,&tv);
  1722.     if (FD_ISSET(soc,&fds))
  1723.       return 1;
  1724.     else
  1725.       return 0;
  1726.   } else
  1727.     return 0;
  1728. }
  1729.  
  1730.  
  1731. // lecture d'un bloc sur une socket (ou un fichier!)
  1732. // >=0 : nombre d'octets lus
  1733. // <0 : fin ou erreur
  1734. HTS_INLINE LLint http_fread1(htsblk* r) {
  1735.   //int bufl=TAILLE_BUFFER;  // taille d'un buffer max.
  1736.   return http_xfread1(r,TAILLE_BUFFER);
  1737. }
  1738.  
  1739. // idem, sauf qu'ici on peut choisir la taille max de donnΘes α recevoir
  1740. // SI bufl==0 alors le buffer est censΘ Ωtre de 8kos, et on recoit par bloc de lignes
  1741. // en Θliminant les cr (ex: header), arrΩt si double-lf
  1742. // SI bufl==-1 alors le buffer est censΘ Ωtre de 8kos, et on recoit ligne par ligne
  1743. // en Θliminant les cr (ex: header), arrΩt si double-lf
  1744. // Note: les +1 dans les malloc sont d√s α l'octet nul rajoutΘ en fin de fichier
  1745. LLint http_xfread1(htsblk* r,int bufl) {
  1746.   int nl=-1;
  1747.  
  1748.   // EOF
  1749.   if (r->totalsize > 0 && r->size == r->totalsize) {
  1750.     return READ_EOF;
  1751.   }
  1752.  
  1753.   if (bufl>0) {
  1754.     if (!r->is_write) {     // stocker en mΘmoire
  1755.       if (r->totalsize>0) {    // totalsize dΘterminΘ ET ALLOUE
  1756.         if (r->adr==NULL) {
  1757.           r->adr = (char*) malloct((size_t) r->totalsize + 1);
  1758.           r->size = 0;
  1759.         }
  1760.         if (r->adr != NULL) {
  1761.           // lecture
  1762.           nl = hts_read(r,r->adr + ((int) r->size),(int) (r->totalsize-r->size) );     /* NO 32 bit overlow possible here (no 4GB html!) */
  1763.           // nouvelle taille
  1764.           if (nl >= 0) r->size+=nl;
  1765.  
  1766.           /*
  1767.           if (r->size >= r->totalsize)
  1768.             nl = -1;  // break
  1769.           */
  1770.           
  1771.           r->adr[r->size]='\0';    // caractΦre NULL en fin au cas o∙ l'on traite des HTML
  1772.         }
  1773.         
  1774.       } else {                 // inconnu..
  1775.         // rΘserver de la mΘmoire?
  1776.         if (r->adr==NULL) {
  1777. #if HDEBUG
  1778.           printf("..alloc xfread\n");
  1779. #endif
  1780.           r->adr=(char*) malloct(bufl + 1);
  1781.           r->size=0;
  1782.         }
  1783.         else {
  1784. #if HDEBUG
  1785.           printf("..realloc xfread1\n");
  1786. #endif
  1787.           r->adr=(char*) realloct(r->adr,(int)r->size+bufl + 1);
  1788.         }
  1789.         
  1790.         if (r->adr!=NULL) {
  1791.           // lecture
  1792.           nl = hts_read(r,r->adr+(int)r->size,bufl);
  1793.           if (nl > 0) {
  1794.             // resize
  1795.             r->adr=(char*) realloct(r->adr,(int)r->size+nl + 1);
  1796.             // nouvelle taille
  1797.             r->size+=nl;
  1798.             // octet nul
  1799.             if (r->adr) r->adr[r->size]='\0';
  1800.  
  1801.           } // sinon on a fini
  1802. #if HDEBUG
  1803.           else if (nl < 0)
  1804.             printf("..end read (%d)\n", nl);
  1805. #endif
  1806.         }
  1807. #if HDEBUG
  1808.         else printf("..-> error\n");
  1809. #endif
  1810.       }
  1811.  
  1812.       // pas de adr=erreur
  1813.       if (r->adr == NULL) nl = READ_ERROR;
  1814.  
  1815.     } else {    // stocker sur disque
  1816.       char* buff;
  1817.       buff=(char*) malloct(bufl);
  1818.       if (buff!=NULL) {
  1819.         // lecture
  1820.         nl = hts_read(r,buff,bufl);
  1821.         // nouvelle taille
  1822.         if (nl > 0) { 
  1823.           r->size+=nl;
  1824.           if (fwrite(buff,1,nl,r->out)!=nl) {
  1825.             r->statuscode=STATUSCODE_INVALID;
  1826.             strcpybuff(r->msg,"Write error on disk");
  1827.             nl=READ_ERROR;
  1828.           }
  1829.         }
  1830.  
  1831.         //if ((nl < 0) || ((r->totalsize>0) && (r->size >= r->totalsize)))
  1832.         //  nl=-1;  // break
  1833.  
  1834.         // libΘrer bloc tempo
  1835.         freet(buff);
  1836.       } else
  1837.         nl=READ_ERROR;
  1838.       
  1839.       if ((nl < 0) && (r->out!=NULL)) {
  1840.         fflush(r->out); 
  1841.       }
  1842.         
  1843.         
  1844.     } // stockage disque ou mΘmoire
  1845.  
  1846.   } else if (bufl == -2) {  // force reserve
  1847.     if (r->adr==NULL) {
  1848.       r->adr=(char*) malloct(8192);
  1849.       r->size=0;
  1850.       return 0;
  1851.     }
  1852.     return -1;
  1853.   } else {    // rΘception d'un en-tΩte octet par octet
  1854.     int count=256;
  1855.     int tot_nl=0;
  1856.     int lf_detected=0;
  1857.     int at_begining=1;
  1858.     do {
  1859.       nl = READ_INTERNAL_ERROR;
  1860.       count--;
  1861.       if (r->adr==NULL) {
  1862.         r->adr=(char*) malloct(8192);
  1863.         r->size=0;
  1864.       }
  1865.       if (r->adr!=NULL) {
  1866.         if (r->size < 8190) {
  1867.           // lecture
  1868.           nl = hts_read(r,r->adr+r->size,1);
  1869.           if (nl > 0) {
  1870.             // exit if:
  1871.             // lf detected AND already detected before
  1872.             // or
  1873.             // lf detected AND first character read
  1874.             if (*(r->adr+r->size) == 10) {
  1875.               if (lf_detected || (at_begining) || (bufl<0))
  1876.                 count=-1;
  1877.               lf_detected=1;
  1878.             }
  1879.             if (*(r->adr+r->size) != 13) {   // sauter caractΦres 13
  1880.               if (
  1881.                 (*(r->adr+r->size) != 10)
  1882.                 &&
  1883.                 (*(r->adr+r->size) != 13)
  1884.                 ) {
  1885.                 // restart for new line
  1886.                 lf_detected=0;
  1887.               }
  1888.               (r->size)++;
  1889.               at_begining=0;
  1890.             }
  1891.             *(r->adr+r->size)='\0';    // terminer par octet nul
  1892.           }
  1893.         }
  1894.       }
  1895.       if (nl >= 0) {
  1896.         tot_nl+=nl;
  1897.         if (!check_readinput(r))
  1898.           count=-1;
  1899.       }
  1900.     } while((nl >= 0) && (count>0));
  1901.     if (nl >= 0) {
  1902.       nl = tot_nl;
  1903.     }
  1904.   }
  1905.   // EOF
  1906.   if (r->totalsize > 0 && r->size == r->totalsize) {
  1907.     return READ_EOF;
  1908.   } else {
  1909.     return nl;
  1910.   }
  1911. }
  1912.  
  1913.  
  1914. // teste une adresse, et suit l'Θventuel chemin "moved"
  1915. // retourne 200 ou le code d'erreur (404=NOT FOUND, etc)
  1916. // copie dans loc la vΘritable adresse si celle-ci est diffΘrente
  1917. htsblk http_location(httrackp *opt,char* adr,char* fil,char* loc) {
  1918.   htsblk retour;
  1919.   int retry=0;
  1920.   int tryagain;
  1921.   // note: "RFC says"
  1922.   // 5 boucles au plus, on en teste au plus 8 ici
  1923.   // sinon abandon..
  1924.   do {
  1925.     tryagain=0;
  1926.     switch ((retour=http_test(opt,adr,fil,loc)).statuscode) {
  1927.     case HTTP_OK:
  1928.       break;   // ok!
  1929.     case HTTP_MOVED_PERMANENTLY:
  1930.     case HTTP_FOUND:
  1931.     case HTTP_SEE_OTHER:
  1932.     case HTTP_TEMPORARY_REDIRECT: // moved!
  1933.       // recalculer adr et fil!
  1934.       if (ident_url_absolute(loc,adr,fil)!=-1) {
  1935.         tryagain=1;  // retenter
  1936.         retry++;     // ..encore une fois
  1937.       }
  1938.     }
  1939.   } while((tryagain) && (retry<5+3));
  1940.   return retour;
  1941. }
  1942.  
  1943.  
  1944. // teste si une URL (validitΘ, header, taille)
  1945. // retourne 200 ou le code d'erreur (404=NOT FOUND, etc)
  1946. // en cas de moved xx, dans location
  1947. // abandonne dΘsormais au bout de 30 secondes (aurevoir les sites
  1948. // qui nous font poireauter 5 heures..) -> -2=timeout
  1949. htsblk http_test(httrackp *opt,char* adr,char* fil,char* loc) {
  1950.   T_SOC soc;
  1951.   htsblk retour;
  1952.   //int rcvsize=-1;
  1953.   //char* rcv=NULL;    // adresse de retour
  1954.   //int bufl=TAILLE_BUFFER;    // 8Ko de buffer
  1955.   TStamp tl;
  1956.   int timeout=30;  // timeout pour un check (arbitraire) // **
  1957.  
  1958.   // pour abandonner un site trop lent
  1959.   tl=time_local();
  1960.  
  1961.   loc[0]='\0';
  1962.   memset(&retour, 0, sizeof(htsblk));    // effacer
  1963.   retour.location=loc;    // si non nul, contiendra l'adresse vΘritable en cas de moved xx
  1964.  
  1965.   //soc=http_fopen(adr,fil,&retour,NULL);  // ouvrir, + header
  1966.  
  1967.   // on ouvre en head, et on traite l'en tΩte
  1968.   soc=http_xfopen(opt,1,0,1,NULL,adr,fil,&retour);  // ouvrir HEAD, + envoi header
  1969.   
  1970.   if (soc!=INVALID_SOCKET) {
  1971.     int e=0;
  1972.     // tant qu'on a des donnΘes, et qu'on ne recoit pas deux LF, et que le timeout n'arrie pas
  1973.     do {
  1974.       if (http_xfread1(&retour,0) < 0)
  1975.         e=1;
  1976.       else {
  1977.         if (retour.adr!=NULL) {
  1978.           if ((retour.adr[retour.size-1]!=10) || (retour.adr[retour.size-2]!=10))
  1979.             e=1;
  1980.         }
  1981.       }
  1982.             
  1983.       if (!e) {
  1984.         if ((time_local()-tl)>=timeout) {
  1985.           e=-1;
  1986.         }
  1987.       }
  1988.       
  1989.     } while (!e);
  1990.     
  1991.     if (e==1) {
  1992.       if (adr!=NULL) {
  1993.         int ptr=0;
  1994.         char rcvd[1100];
  1995.  
  1996.         // note: en gros recopie du traitement de back_wait()
  1997.         //
  1998.  
  1999.  
  2000.         // ----------------------------------------
  2001.         // traiter en-tΩte!
  2002.         // status-line α rΘcupΘrer
  2003.         ptr+=binput(retour.adr+ptr,rcvd,1024);
  2004.         if (strnotempty(rcvd)==0)
  2005.           ptr+=binput(retour.adr+ptr,rcvd,1024);    // "certains serveurs buggΘs envoient un \n au dΘbut" (RFC)
  2006.         
  2007.         // traiter status-line
  2008.         treatfirstline(&retour,rcvd);
  2009.         
  2010. #if HDEBUG
  2011.         printf("(Buffer) Status-Code=%d\n",retour.statuscode);
  2012. #endif
  2013.         
  2014.         // en-tΩte
  2015.         
  2016.         // header // ** !attention! HTTP/0.9 non supportΘ
  2017.         do {
  2018.           ptr+=binput(retour.adr+ptr,rcvd,1024);          
  2019. #if HDEBUG
  2020.           printf("(buffer)>%s\n",rcvd);      
  2021. #endif
  2022.           if (strnotempty(rcvd))
  2023.             treathead(NULL,NULL,NULL,&retour,rcvd);  // traiter
  2024.           
  2025.         } while(strnotempty(rcvd));
  2026.         // ----------------------------------------                    
  2027.         
  2028.         // libΘrer mΘmoire
  2029.         if (retour.adr!=NULL) { freet(retour.adr); retour.adr=NULL; }
  2030.       }
  2031.     } else {
  2032.       retour.statuscode=STATUSCODE_TIMEOUT;
  2033.       strcpybuff(retour.msg,"Timeout While Testing");
  2034.     }
  2035.     
  2036.     
  2037. #if HTS_DEBUG_CLOSESOCK
  2038.     DEBUG_W("http_test: deletehttp\n");
  2039. #endif
  2040.     deletehttp(&retour);
  2041.     retour.soc=INVALID_SOCKET;
  2042.   }
  2043.   return retour;    
  2044. }
  2045.  
  2046. // CrΘe un lien (http) vers une adresse internet iadr
  2047. // retour: structure (adresse, taille, message si erreur (si !adr))
  2048. // peut ouvrir avec des connect() non bloquants: waitconnect=0/1
  2049. int newhttp(httrackp *opt,const char* _iadr,htsblk* retour,int port,int waitconnect) {  
  2050.   t_fullhostent fullhostent_buffer;    // buffer pour resolver
  2051.   T_SOC soc;                           // descipteur de la socket
  2052.   char* iadr;
  2053.   // unsigned short int port;
  2054.   
  2055.   // si iadr="#" alors c'est une fausse URL, mais un vrai fichier
  2056.   // local.
  2057.   // utile pour les tests!
  2058.   //## if (iadr[0]!=lOCAL_CHAR) {
  2059.   if (strcmp(_iadr,"file://") != 0) {           /* non fichier */
  2060.     SOCaddr server;
  2061.     int server_size=sizeof(server);
  2062.     t_hostent* hp;    
  2063.     // effacer structure
  2064.     memset(&server, 0, sizeof(server));
  2065.  
  2066.     // tester un Θventuel id:pass et virer id:pass@ si dΘtectΘ
  2067.     iadr = jump_identification(_iadr);
  2068.   
  2069. #if HDEBUG
  2070.     printf("gethostbyname\n");
  2071. #endif
  2072.     
  2073.     // tester un Θventuel port
  2074.     if (port==-1) {
  2075.       char *a=jump_toport(iadr);
  2076. #if HTS_USEOPENSSL
  2077.       if (retour->ssl)
  2078.         port=443;
  2079.       else
  2080.         port=80;    // port par dΘfaut
  2081. #else
  2082.       port=80;    // port par dΘfaut
  2083. #endif
  2084.       if (a) {
  2085.         char BIGSTK iadr2[HTS_URLMAXSIZE*2];
  2086.         int i=-1;
  2087.         iadr2[0]='\0';
  2088.         sscanf(a+1,"%d",&i);
  2089.         if (i!=-1) {
  2090.           port=(unsigned short int) i;
  2091.         }
  2092.         
  2093.         // adresse vΘritable (sans :xx)
  2094.         strncatbuff(iadr2,iadr,(int) (a - iadr));
  2095.  
  2096.         // adresse sans le :xx
  2097.         hp = hts_gethostbyname(opt,iadr2, &fullhostent_buffer);
  2098.         
  2099.       } else {
  2100.  
  2101.         // adresse normale (port par dΘfaut par la suite)
  2102.         hp = hts_gethostbyname(opt,iadr, &fullhostent_buffer);
  2103.         
  2104.       }
  2105.       
  2106.     } else    // port dΘfini
  2107.       hp = hts_gethostbyname(opt,iadr, &fullhostent_buffer);
  2108.  
  2109.     
  2110.     // Conversion iadr -> adresse
  2111.     // structure recevant le nom de l'h⌠te, etc
  2112.     //struct     hostent     *hp;
  2113.     if (hp == NULL) {
  2114. #if DEBUG
  2115.       printf("erreur gethostbyname\n");
  2116. #endif
  2117.       if (retour && retour->msg) {
  2118. #ifdef _WIN32
  2119.         int last_errno = WSAGetLastError();
  2120.         sprintf(retour->msg,"Unable to get server's address: %s", strerror(last_errno));
  2121. #else
  2122.         int last_errno = errno;
  2123.         sprintf(retour->msg,"Unable to get server's address: %s", strerror(last_errno));
  2124. #endif
  2125.       }
  2126.       return INVALID_SOCKET;
  2127.     }  
  2128.     // copie adresse
  2129.     SOCaddr_copyaddr(server, server_size, hp->h_addr_list[0], hp->h_length);
  2130.     // make a copy for external clients
  2131.     retour->address_size = sizeof(retour->address);
  2132.     SOCaddr_copyaddr(retour->address, retour->address_size, hp->h_addr_list[0], hp->h_length);
  2133.     // memcpy(&SOCaddr_sinaddr(server), hp->h_addr_list[0], hp->h_length);
  2134.      
  2135.     // crΘer ("attachement") une socket (point d'accΦs) internet,en flot
  2136. #if HDEBUG
  2137.     printf("socket\n");
  2138. #endif
  2139. #if HTS_WIDE_DEBUG    
  2140.     DEBUG_W("socket\n");
  2141. #endif
  2142.     soc = (T_SOC) socket(SOCaddr_sinfamily(server), SOCK_STREAM, 0);
  2143.     if (retour != NULL) {
  2144.       retour->debugid = HTS_STAT.stat_sockid++;
  2145.     }
  2146. #if HTS_WIDE_DEBUG    
  2147.     DEBUG_W("socket()=%d\n" _ (int) soc);
  2148. #endif
  2149.     if (soc==INVALID_SOCKET) {
  2150.       if (retour && retour->msg) {
  2151. #ifdef _WIN32
  2152.         int last_errno = WSAGetLastError();
  2153.         sprintf(retour->msg,"Unable to create a socket: %s", strerror(last_errno));
  2154. #else
  2155.         int last_errno = errno;
  2156.         sprintf(retour->msg,"Unable to create a socket: %s", strerror(last_errno));
  2157. #endif
  2158.       }
  2159.       return INVALID_SOCKET;                        // erreur crΘation socket impossible
  2160.     }
  2161.  
  2162.     // bind this address
  2163.     if (retour != NULL && retour->req.proxy.bindhost[0] != 0) {
  2164.       t_fullhostent bind_buffer;
  2165.       hp = hts_gethostbyname(opt, retour->req.proxy.bindhost, &bind_buffer);
  2166.       if (hp == NULL ||
  2167.         bind(soc, (struct sockaddr *)hp->h_addr_list[0], hp->h_length) != 0) {
  2168.           if (retour && retour->msg) {
  2169. #ifdef _WIN32
  2170.             int last_errno = WSAGetLastError();
  2171.             sprintf(retour->msg,"Unable to bind the specificied server address: %s", strerror(last_errno));
  2172. #else
  2173.             int last_errno = errno;
  2174.             sprintf(retour->msg,"Unable to bind the specificied server address: %s", strerror(last_errno));
  2175. #endif
  2176.           }
  2177.           deletesoc(soc);
  2178.           return INVALID_SOCKET;
  2179.       }
  2180.     }
  2181.     
  2182.     // structure: connexion au domaine internet, port 80 (ou autre)
  2183.     SOCaddr_initport(server, port);
  2184. #if HDEBUG
  2185.     printf("==%d\n",soc);
  2186. #endif
  2187.  
  2188.     // connexion non bloquante?
  2189.     if (!waitconnect ) {
  2190.       unsigned long p=1;  // non bloquant
  2191. #ifdef _WIN32
  2192.       ioctlsocket(soc,FIONBIO,&p);
  2193. #else
  2194.       ioctl(soc,FIONBIO,&p);
  2195. #endif
  2196.     }
  2197.     
  2198.     // Connexion au serveur lui mΩme
  2199. #if HDEBUG
  2200.     printf("connect\n");
  2201. #endif
  2202.     HTS_STAT.last_connect = mtime_local();
  2203.     
  2204. #if HTS_WIDE_DEBUG
  2205.     DEBUG_W("connect\n");
  2206. #endif
  2207. #ifdef _WIN32
  2208.     if (connect(soc, (const struct sockaddr FAR *)&server, server_size) != 0) {
  2209. #else
  2210.       if (connect(soc, (struct sockaddr *)&server, server_size) == -1) {
  2211. #endif
  2212.  
  2213.         // bloquant
  2214.         if (waitconnect) {
  2215. #if HDEBUG
  2216.           printf("unable to connect!\n");
  2217. #endif
  2218.           if (retour && retour->msg) {
  2219. #ifdef _WIN32
  2220.             int last_errno = WSAGetLastError();
  2221.             sprintf(retour->msg,"Unable to connect to the server: %s", strerror(last_errno));
  2222. #else
  2223.             int last_errno = errno;
  2224.             sprintf(retour->msg,"Unable to connect to the server: %s", strerror(last_errno));
  2225. #endif
  2226.           }
  2227.           /* Close the socket and notify the error!!! */
  2228.           deletesoc(soc);
  2229.           return INVALID_SOCKET;
  2230.         }
  2231.       }
  2232. #if HTS_WIDE_DEBUG    
  2233.       DEBUG_W("connect done\n");
  2234. #endif
  2235.       
  2236. #if HDEBUG
  2237.       printf("connexion Θtablie\n");
  2238. #endif
  2239.     
  2240.     // A partir de maintenant, on peut envoyer et recevoir des donnΘes
  2241.     // via le flot identifiΘ par soc (socket): write(soc,adr,taille) et 
  2242.     // read(soc,adr,taille)
  2243.  
  2244.   } else {    // on doit ouvrir un fichier local!
  2245.     // il sera gΘrΘ de la mΩme maniΦre qu'une socket (c'est idem!)
  2246.  
  2247.     soc=LOCAL_SOCKET_ID;    // pseudo-socket locale..
  2248.     // soc sera remplacΘ lors d'un http_fopen() par un handle vΘritable!
  2249.  
  2250.   }   // teste fichier local ou http
  2251.   
  2252.   return soc;
  2253. }
  2254.  
  2255.  
  2256.  
  2257. // couper http://www.truc.fr/pub/index.html -> www.truc.fr /pub/index.html
  2258. // retour=-1 si erreur.
  2259. // si file://... alors adresse=file:// (et coupe le ?query dans ce cas)
  2260. int ident_url_absolute(const char* url,char* adr,char* fil) {
  2261.   int pos=0;
  2262.   int scheme=0;
  2263.  
  2264.   // effacer adr et fil
  2265.   adr[0]=fil[0]='\0';
  2266.   
  2267. #if HDEBUG
  2268.   printf("protocol: %s\n",url);
  2269. #endif
  2270.  
  2271.   // Scheme?
  2272.   {
  2273.     const char* a=url;
  2274.     while (isalpha((unsigned char)*a))
  2275.       a++;
  2276.     if (*a == ':')
  2277.       scheme=1;
  2278.   }
  2279.  
  2280.   // 1. optional scheme ":"
  2281.   if ((pos=strfield(url,"file:"))) {    // fichier local!! (pour les tests)
  2282.     //!!p+=3;
  2283.     strcpybuff(adr,"file://");
  2284.   } else if ((pos=strfield(url,"http:"))) {    // HTTP
  2285.     //!!p+=3;
  2286.   } else if ((pos=strfield(url,"ftp:"))) {    // FTP
  2287.     strcpybuff(adr,"ftp://");    // FTP!!
  2288.     //!!p+=3;
  2289. #if HTS_USEOPENSSL
  2290.   } else if (SSL_is_available && (pos=strfield(url,"https:"))) {    // HTTPS
  2291.     strcpybuff(adr,"https://");
  2292. #endif
  2293. #if HTS_USEMMS
  2294.   } else if ((pos = strfield(url,"mms:"))) {    // mms
  2295.     strcpybuff(adr,"mms://");
  2296. #endif
  2297.   } else if (scheme) {
  2298.     return -1;    // erreur non reconnu
  2299.   } else
  2300.     pos=0;
  2301.  
  2302.   // 2. optional "//" authority
  2303.   if (strncmp(url+pos,"//",2)==0)
  2304.     pos+=2;
  2305.  
  2306.   // (url+pos) now points to the path (not net path)
  2307.  
  2308.   //## if (adr[0]!=lOCAL_CHAR) {    // adresse normale http
  2309.   if (!strfield(adr,"file:")) {      // PAS file://
  2310.     const char *p,*q;
  2311.     p=url+pos;
  2312.  
  2313.     // p pointe sur le dΘbut de l'adresse, ex: www.truc.fr/sommaire/index.html
  2314.     q=strchr(jump_identification(p),'/');
  2315.     if (q==0) q=strchr(jump_identification(p),'?');     // http://www.foo.com?bar=1
  2316.     if (q==0) q=p+strlen(p);  // pointe sur \0
  2317.     // q pointe sur le chemin, ex: index.html?query=recherche
  2318.     
  2319.     // chemin www... trop long!!
  2320.     if ( ( ((int) (q - p)) )  > HTS_URLMAXSIZE) {
  2321.       //strcpybuff(retour.msg,"Path too long");
  2322.       return -1;    // erreur
  2323.     }
  2324.     
  2325.     // recopier adresse www..
  2326.     strncatbuff(adr,p, ((int) (q - p)) );
  2327.     // *( adr+( ((int) q) - ((int) p) ) )=0;  // faut arrΩter la fumette!
  2328.     // recopier chemin /pub/..
  2329.     if (q[0] != '/')    // page par dΘfaut (/)
  2330.       strcatbuff(fil,"/");
  2331.     strcatbuff(fil,q);
  2332.     // SECURITE:
  2333.     // simplifier url pour les ../
  2334.     fil_simplifie(fil);
  2335.   } else {    // localhost file://
  2336.     const char *p;
  2337.     int i;
  2338.     char* a;
  2339.     
  2340.     p=url+pos;
  2341.     if (*p == '/' || *p == '\\') {  /* file:///.. */
  2342.       strcatbuff(fil,p);    // fichier local ; adr="#"
  2343.     } else {
  2344.       if (p[1] != ':') {
  2345.         strcatbuff(fil,"//");   /* file://server/foo */
  2346.         strcatbuff(fil,p);
  2347.       } else {
  2348.         strcatbuff(fil,p);    // file://C:\..
  2349.       }
  2350.     }
  2351.     
  2352.     a=strchr(fil,'?');
  2353.     if (a) 
  2354.       *a='\0';      /* couper query (inutile pour file:// lors de la requΩte) */
  2355.     // filtrer les \\ -> / pour les fichiers DOS
  2356.     for(i=0;i<(int) strlen(fil);i++)
  2357.       if (fil[i]=='\\')
  2358.         fil[i]='/';
  2359.   }
  2360.  
  2361.   // no hostname
  2362.   if (!strnotempty(adr))
  2363.     return -1;    // erreur non reconnu
  2364.  
  2365.   // nommer au besoin.. (non utilisΘ normalement)
  2366.   if (!strnotempty(fil))
  2367.     strcpybuff(fil,"default-index.html");
  2368.  
  2369.   // case insensitive pour adresse
  2370.   {
  2371.     char *a=jump_identification(adr);
  2372.     while(*a) {
  2373.       if ((*a>='A') && (*a<='Z'))
  2374.         *a+='a'-'A';       
  2375.       a++;
  2376.     }
  2377.   }
  2378.   
  2379.   return 0;
  2380. }
  2381.  
  2382. /* simplify ../ and ./ */
  2383. void fil_simplifie(char* f) {
  2384.   char *a, *b;
  2385.   char *rollback[128];
  2386.   int rollid = 0;
  2387.   char lc = '/';
  2388.   int query = 0;
  2389.   int wasAbsolute = (*f == '/');
  2390.   for(a = b = f ; *a != '\0' ; ) {
  2391.     if (*a == '?')
  2392.       query = 1;
  2393.     if (query == 0 && lc == '/' && a[0] == '.' && a[1] == '/') {    /* foo/./bar or ./foo  */
  2394.       a += 2;
  2395.     }
  2396.     else if (query == 0 && lc == '/' && a[0] == '.' && a[1] == '.' && ( a[2] == '/' || a[2] == '\0' ) ) {    /* foo/../bar or ../foo or .. */
  2397.       if (a[2] == '\0')
  2398.         a += 2;
  2399.       else
  2400.         a += 3;
  2401.       if (rollid > 1) {
  2402.         rollid--;
  2403.         b = rollback[rollid - 1];
  2404.       } else {   /* too many ../ */
  2405.         rollid = 0;
  2406.         b = f;
  2407.         if (wasAbsolute)
  2408.           b++;   /* after the / */
  2409.       }
  2410.     }
  2411.     else {
  2412.       *b++ = lc = *a;
  2413.       if (*a == '/') {
  2414.         rollback[rollid++] = b;
  2415.         if (rollid >= 127) {
  2416.           *f = '\0';      /* ERROR */
  2417.           break;
  2418.         }
  2419.       }
  2420.       a++;
  2421.     }
  2422.   }
  2423.   *b = '\0';
  2424.   if (*f == '\0') {
  2425.     if (wasAbsolute) {
  2426.       f[0] = '/';
  2427.       f[1] = '\0';
  2428.     } else {
  2429.       f[0] = '.';
  2430.       f[1] = '/';
  2431.       f[2] = '\0';
  2432.     }
  2433.   }
  2434. }
  2435.  
  2436. // fermer liaison fichier ou socket
  2437. HTS_INLINE void deletehttp(htsblk* r) {
  2438. #if HTS_DEBUG_CLOSESOCK
  2439.     DEBUG_W("deletehttp: (htsblk*) 0x%p\n" _ (void*) r);
  2440. #endif
  2441. #if HTS_USEOPENSSL
  2442.     /* Free OpenSSL structures */
  2443.     if (SSL_is_available && r->ssl_con) {
  2444.       SSL_shutdown(r->ssl_con);
  2445.       SSL_free(r->ssl_con);
  2446.       r->ssl_con=NULL;
  2447.     }
  2448. #endif  
  2449.   if (r->soc!=INVALID_SOCKET) {
  2450.     if (r->is_file) {
  2451.       if (r->fp)
  2452.         fclose(r->fp);
  2453.       r->fp=NULL;
  2454.     } else {
  2455.       if (r->soc!=LOCAL_SOCKET_ID)
  2456.         deletesoc_r(r);
  2457.     }
  2458.     r->soc=INVALID_SOCKET;
  2459.   }
  2460. }
  2461.  
  2462. // free the addr buffer
  2463. // always returns 1
  2464. HTS_INLINE int deleteaddr(htsblk* r) {
  2465.   if (r->adr != NULL) {
  2466.     freet(r->adr);
  2467.     r->adr = NULL;
  2468.   }
  2469.   if (r->headers != NULL) {
  2470.     freet(r->headers);
  2471.     r->headers = NULL;
  2472.   }
  2473.   return 1;
  2474. }
  2475.  
  2476. // fermer une socket
  2477. HTS_INLINE void deletesoc(T_SOC soc) {
  2478.   if (soc!=INVALID_SOCKET && soc!=LOCAL_SOCKET_ID) {
  2479. #if HTS_WIDE_DEBUG    
  2480.     DEBUG_W("close %d\n" _ (int) soc);
  2481. #endif
  2482. #ifdef _WIN32
  2483.     closesocket(soc);
  2484. #else
  2485.     close(soc);
  2486. #endif
  2487. #if HTS_WIDE_DEBUG    
  2488.     DEBUG_W(".. done\n");
  2489. #endif
  2490.   }
  2491. }
  2492.  
  2493. /* Will also clean other things */
  2494. HTS_INLINE void deletesoc_r(htsblk* r) {
  2495. #if HTS_USEOPENSSL
  2496.   if (SSL_is_available && r->ssl_con) {
  2497.     SSL_shutdown(r->ssl_con);
  2498.     // SSL_CTX_set_quiet_shutdown(r->ssl_con->ctx, 1);
  2499.     SSL_free(r->ssl_con);
  2500.     r->ssl_con=NULL;
  2501.   }
  2502. #endif
  2503.   if (r->soc!=INVALID_SOCKET) {
  2504.     deletesoc(r->soc);
  2505.     r->soc=INVALID_SOCKET;
  2506.   }
  2507. }
  2508.  
  2509. // renvoi le nombre de secondes depuis 1970
  2510. HTS_INLINE TStamp time_local(void) {
  2511.   return ((TStamp) time(NULL));
  2512. }
  2513.  
  2514. // number of millisec since 1970
  2515. HTSEXT_API HTS_INLINE TStamp mtime_local(void) {
  2516. #ifndef HTS_DO_NOT_USE_FTIME
  2517.   struct timeb B;
  2518.   ftime( &B );
  2519.   return (TStamp) ( ((TStamp) B.time * (TStamp) 1000)
  2520.         + ((TStamp) B.millitm) );
  2521. #else
  2522.   // not precise..
  2523.   return (TStamp) ( ((TStamp) time_local() * (TStamp) 1000)
  2524.         + ((TStamp) 0) );
  2525. #endif
  2526. }
  2527.  
  2528. // convertit un nombre de secondes en temps (chaine)
  2529. void sec2str(char *st,TStamp t) {
  2530.   int j,h,m,s;
  2531.   
  2532.   j=(int) (t/(3600*24));
  2533.   t-=((TStamp) j)*(3600*24);
  2534.   h=(int) (t/(3600));
  2535.   t-=((TStamp) h)*3600;
  2536.   m=(int) (t/60);
  2537.   t-=((TStamp) m)*60;
  2538.   s=(int) t;
  2539.   
  2540.   if (j>0)
  2541.     sprintf(st,"%d days, %d hours %d minutes %d seconds",j,h,m,s);
  2542.   else if (h>0)
  2543.     sprintf(st,"%d hours %d minutes %d seconds",h,m,s);
  2544.   else if (m>0)
  2545.     sprintf(st,"%d minutes %d seconds",m,s);
  2546.   else
  2547.     sprintf(st,"%d seconds",s);
  2548. }
  2549.  
  2550. // idem, plus court (chaine)
  2551. HTSEXT_API void qsec2str(char *st,TStamp t) {
  2552.   int j,h,m,s;
  2553.   
  2554.   j=(int) (t/(3600*24));
  2555.   t-=((TStamp) j)*(3600*24);
  2556.   h=(int) (t/(3600));
  2557.   t-=((TStamp) h)*3600;
  2558.   m=(int) (t/60);
  2559.   t-=((TStamp) m)*60;
  2560.   s=(int) t;
  2561.   
  2562.   if (j>0)
  2563.     sprintf(st,"%dd,%02dh,%02dmin%02ds",j,h,m,s);
  2564.   else if (h>0)
  2565.     sprintf(st,"%dh,%02dmin%02ds",h,m,s);
  2566.   else if (m>0)
  2567.     sprintf(st,"%dmin%02ds",m,s);
  2568.   else
  2569.     sprintf(st,"%ds",s);
  2570. }
  2571.  
  2572.  
  2573. // heure actuelle, GMT, format rfc (taille buffer 256o)
  2574. void time_gmt_rfc822(char* s) {
  2575.   time_t tt;
  2576.   struct tm* A;
  2577.   tt=time(NULL);
  2578.   A=gmtime(&tt);
  2579.   if (A==NULL)
  2580.     A=localtime(&tt);
  2581.   time_rfc822(s,A);
  2582. }
  2583.  
  2584. // heure actuelle, format rfc (taille buffer 256o)
  2585. void time_local_rfc822(char* s) {
  2586.   time_t tt;
  2587.   struct tm* A;
  2588.   tt=time(NULL);
  2589.   A=localtime(&tt);
  2590.   time_rfc822_local(s,A);
  2591. }
  2592.  
  2593. /* convertir une chaine en temps */
  2594. struct tm* convert_time_rfc822(struct tm *result, const char* s) {
  2595.   char months[]="jan feb mar apr may jun jul aug sep oct nov dec";
  2596.   char str[256];
  2597.   char* a;
  2598.   /* */
  2599.   int result_mm=-1;
  2600.   int result_dd=-1;
  2601.   int result_n1=-1;
  2602.   int result_n2=-1;
  2603.   int result_n3=-1;
  2604.   int result_n4=-1;
  2605.   /* */
  2606.  
  2607.   if ((int) strlen(s) > 200)
  2608.     return NULL;
  2609.   strcpybuff(str,s);
  2610.   hts_lowcase(str);
  2611.   /* Θliminer :,- */
  2612.   while( (a=strchr(str,'-')) ) *a=' ';
  2613.   while( (a=strchr(str,':')) ) *a=' ';
  2614.   while( (a=strchr(str,',')) ) *a=' ';
  2615.   /* tokeniser */
  2616.   a=str;
  2617.   while(*a) {
  2618.     char *first,*last;
  2619.     char tok[256];
  2620.     /* dΘcouper mot */
  2621.     while(*a==' ') a++;   /* sauter espaces */
  2622.     first=a;
  2623.     while((*a) && (*a!=' ')) a++;
  2624.     last=a;
  2625.     tok[0]='\0';
  2626.     if (first!=last) {
  2627.       char* pos;
  2628.       strncatbuff(tok,first,(int) (last - first));
  2629.       /* analyser */
  2630.       if ( (pos=strstr(months,tok)) ) {               /* month always in letters */
  2631.         result_mm=((int) (pos - months))/4;
  2632.       } else {
  2633.         int number;
  2634.         if (sscanf(tok,"%d",&number) == 1) {      /* number token */
  2635.           if (result_dd<0)                        /* day always first number */
  2636.             result_dd=number;
  2637.           else if (result_n1<0)
  2638.             result_n1=number;
  2639.           else if (result_n2<0)
  2640.             result_n2=number;
  2641.           else if (result_n3<0)
  2642.             result_n3=number;
  2643.           else if (result_n4<0)
  2644.             result_n4=number;
  2645.         }   /* sinon, bruit de fond(+1GMT for exampel) */
  2646.       }
  2647.     }
  2648.   }
  2649.   if ((result_n1>=0) && (result_mm>=0) && (result_dd>=0) && (result_n2>=0) && (result_n3>=0) && (result_n4>=0)) {
  2650.     if (result_n4>=1000) {               /* Sun Nov  6 08:49:37 1994 */
  2651.       result->tm_year=result_n4-1900;
  2652.       result->tm_hour=result_n1;
  2653.       result->tm_min=result_n2;
  2654.       result->tm_sec=max(result_n3,0);
  2655.     } else {                            /* Sun, 06 Nov 1994 08:49:37 GMT or Sunday, 06-Nov-94 08:49:37 GMT */
  2656.       result->tm_hour=result_n2;
  2657.       result->tm_min=result_n3;
  2658.       result->tm_sec=max(result_n4,0);
  2659.       if (result_n1<=50)                /* 00 means 2000 */
  2660.         result->tm_year=result_n1+100;
  2661.       else if (result_n1<1000)          /* 99 means 1999 */
  2662.         result->tm_year=result_n1;
  2663.       else                              /* 2000 */
  2664.         result->tm_year=result_n1-1900;
  2665.     }
  2666.     result->tm_isdst=0;        /* assume GMT */
  2667.     result->tm_yday=-1;        /* don't know */
  2668.     result->tm_wday=-1;        /* don't know */
  2669.     result->tm_mon=result_mm;
  2670.     result->tm_mday=result_dd;
  2671.     return result;
  2672.   }
  2673.   return NULL;
  2674. }
  2675.  
  2676. static time_t getGMT(struct tm *tm) {        /* hey, time_t is local! */
  2677.     time_t t = mktime(tm);
  2678.     if (t != (time_t) -1 && t != (time_t) 0) {
  2679.     /* BSD does not have static "timezone" declared */
  2680. #if (defined(BSD) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD_kernel__))
  2681.     time_t now = time(NULL); 
  2682.     time_t timezone = - localtime(&now)->tm_gmtoff;
  2683. #endif
  2684.     return (time_t) (t - timezone);
  2685.     }
  2686.     return (time_t) -1;
  2687. }
  2688.  
  2689. /* sets file time. -1 if error */
  2690. int set_filetime(const char* file, struct tm* tm_time) {
  2691.     time_t t = getGMT(tm_time);
  2692.     if (t != (time_t) -1) {
  2693.       struct utimbuf tim;
  2694.         memset(&tim, 0, sizeof(tim));
  2695.       tim.actime = tim.modtime = t; 
  2696.         return utime(file, &tim);
  2697.     }
  2698.     return -1;
  2699. }
  2700.  
  2701. /* sets file time from RFC822 date+time, -1 if error*/
  2702. int set_filetime_rfc822(const char* file, const char* date) {
  2703.     struct tm buffer;
  2704.   struct tm* tm_s = convert_time_rfc822(&buffer, date);
  2705.   if (tm_s) {
  2706.     return set_filetime(file,tm_s);
  2707.   } else return -1;
  2708. }
  2709.  
  2710. int get_filetime_rfc822(const char* file, char* date) {
  2711.   struct stat buf;
  2712.   date[0] = '\0';
  2713.   if (stat(file, &buf) == 0) {
  2714.     struct tm* A;
  2715.     time_t tt = buf.st_mtime;
  2716.     A=gmtime(&tt);
  2717.     if (A==NULL)
  2718.       A=localtime(&tt);
  2719.     if (A != NULL) {
  2720.       time_rfc822(date, A);
  2721.       return 1;
  2722.     }
  2723.   }
  2724.   return 0;
  2725. }
  2726.  
  2727. // heure au format rfc (taille buffer 256o)
  2728. HTS_INLINE void time_rfc822(char* s,struct tm * A) {
  2729.   if (A == NULL) {
  2730.     int localtime_returned_null=0;
  2731.     assert(localtime_returned_null);
  2732.   }
  2733.   strftime(s,256,"%a, %d %b %Y %H:%M:%S GMT",A);
  2734. }
  2735.  
  2736. // heure locale au format rfc (taille buffer 256o)
  2737. HTS_INLINE void time_rfc822_local(char* s,struct tm * A) {
  2738.   if (A == NULL) {
  2739.     int localtime_returned_null=0;
  2740.     assert(localtime_returned_null);
  2741.   }
  2742.   strftime(s,256,"%a, %d %b %Y %H:%M:%S",A);
  2743. }
  2744.  
  2745. // conversion en b,Kb,Mb
  2746. HTSEXT_API char* int2bytes(strc_int2bytes2* strc, LLint n) {
  2747.   char** a = int2bytes2(strc, n);
  2748.   strcpybuff(strc->catbuff, a[0]);
  2749.   strcatbuff(strc->catbuff, a[1]);
  2750.   return strc->catbuff;
  2751. }
  2752.  
  2753. // conversion en b/s,Kb/s,Mb/s
  2754. HTSEXT_API char* int2bytessec(strc_int2bytes2* strc, long int n) {
  2755.     char buff[256];
  2756.   char** a = int2bytes2(strc, n);
  2757.   strcpybuff(buff, a[0]);
  2758.   strcatbuff(buff, a[1]);
  2759.   return concat(strc->catbuff, buff, "/s");
  2760. }
  2761. HTSEXT_API char* int2char(strc_int2bytes2* strc, int n) {
  2762.   sprintf(strc->buff2, "%d", n);
  2763.   return strc->buff2;
  2764. }
  2765.  
  2766. // conversion en b,Kb,Mb, nombre et type sΘparΘs
  2767. // limite: 2.10^9.10^6B
  2768.  
  2769. /* See http://physics.nist.gov/cuu/Units/binary.html */
  2770. #define ToLLint(a) ((LLint)(a))
  2771. #define ToLLintKiB (ToLLint(1024))
  2772. #define ToLLintMiB (ToLLintKiB*ToLLintKiB)
  2773. #ifdef HTS_LONGLONG
  2774. #define ToLLintGiB (ToLLintKiB*ToLLintKiB*ToLLintKiB)
  2775. #define ToLLintTiB (ToLLintKiB*ToLLintKiB*ToLLintKiB*ToLLintKiB)
  2776. #define ToLLintPiB (ToLLintKiB*ToLLintKiB*ToLLintKiB*ToLLintKiB*ToLLintKiB)
  2777. #endif
  2778. HTSEXT_API char** int2bytes2(strc_int2bytes2* strc, LLint n) {
  2779.   if (n < ToLLintKiB) {
  2780.     sprintf(strc->buff1,"%d",(int)(LLint)n);
  2781.     strcpybuff(strc->buff2,"B");
  2782.   } else if (n < ToLLintMiB) {
  2783.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/ToLLintKiB)),(int)((LLint)((n%ToLLintKiB)*100)/ToLLintKiB));
  2784.     strcpybuff(strc->buff2,"KiB");
  2785.   }
  2786. #ifdef HTS_LONGLONG
  2787.   else if (n < ToLLintGiB) {
  2788.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintMiB))),(int)((LLint)(((n%(ToLLintMiB))*100)/(ToLLintMiB))));
  2789.     strcpybuff(strc->buff2,"MiB");
  2790.   } else if (n < ToLLintTiB) {
  2791.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintGiB))),(int)((LLint)(((n%(ToLLintGiB))*100)/(ToLLintGiB))));
  2792.     strcpybuff(strc->buff2,"GiB");
  2793.   } else if (n < ToLLintPiB) {
  2794.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintTiB))),(int)((LLint)(((n%(ToLLintTiB))*100)/(ToLLintTiB))));
  2795.     strcpybuff(strc->buff2,"TiB");
  2796.   } else {
  2797.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintPiB))),(int)((LLint)(((n%(ToLLintPiB))*100)/(ToLLintPiB))));
  2798.     strcpybuff(strc->buff2,"PiB");
  2799.   }
  2800. #else
  2801.   else {
  2802.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintMiB))),(int)((LLint)(((n%(ToLLintMiB))*100)/(ToLLintMiB))));
  2803.     strcpybuff(strc->buff2,"MiB");
  2804.   }
  2805. #endif
  2806.   strc->buffadr[0]=strc->buff1;
  2807.   strc->buffadr[1]=strc->buff2;
  2808.   return strc->buffadr;
  2809. }
  2810.  
  2811. #ifdef _WIN32
  2812. #else
  2813. // ignore sigpipe?
  2814. int sig_ignore_flag( int setflag ) {     // flag ignore
  2815.   static int flag=0;   /* YES, this one is true static */
  2816.   if (setflag>=0)
  2817.     flag=setflag;
  2818.   return flag;
  2819. }
  2820. #endif
  2821.  
  2822. // envoi de texte (en tΩtes gΘnΘralement) sur la socket soc
  2823. HTS_INLINE int sendc(htsblk* r, const char* s) {
  2824.   int n, ssz = (int)strlen(s);
  2825.  
  2826. #ifdef _WIN32
  2827. #else
  2828.   sig_ignore_flag(1);
  2829. #endif
  2830. #if HDEBUG
  2831.   write(0,s,ssz);
  2832. #endif
  2833.  
  2834. #if HTS_USEOPENSSL
  2835.   if (SSL_is_available && r->ssl) {
  2836.     n = SSL_write(r->ssl_con, s, ssz);
  2837.   } else
  2838. #endif
  2839.     n = send(r->soc,s,ssz,0);
  2840.  
  2841. #ifdef _WIN32
  2842. #else
  2843.   sig_ignore_flag(0);
  2844. #endif
  2845.  
  2846.   return ( n == ssz ) ? n : -1;
  2847. }
  2848.  
  2849.  
  2850. // Remplace read
  2851. int finput(int fd,char* s,int max) {
  2852.   char c;
  2853.   int j=0;
  2854.   do {
  2855.     //c=fgetc(fp);
  2856.     if (read(fd,&c,1)<=0) {
  2857.       c=0;
  2858.     }
  2859.     if (c!=0) {
  2860.       switch(c) {
  2861.       case 10: c=0; break;
  2862.       case 13: break;  // sauter ces caractΦres
  2863.       default: s[j++]=c; break;
  2864.       }
  2865.     }
  2866.   }  while((c!=0) && (j<max-1));
  2867.   s[j]='\0';
  2868.   return j;
  2869. } 
  2870.  
  2871. // Like linput, but in memory (optimized)
  2872. int binput(char* buff, char* s, int max) {
  2873.   int count = 0;
  2874.   int destCount = 0;
  2875.  
  2876.   // Note: \0 will return 1
  2877.   while(destCount < max && buff != NULL && buff[count] != '\0' && buff[count] != '\n') {
  2878.     if (buff[count] != '\r') {
  2879.       s[destCount++] = buff[count];
  2880.     }
  2881.     count++;
  2882.   }
  2883.   s[destCount] = '\0';
  2884.  
  2885.   // then return the supplemental jump offset
  2886.   return count + 1;
  2887. } 
  2888.  
  2889. // Lecture d'une ligne (peut Ωtre unicode α priori)
  2890. int linput(FILE* fp,char* s,int max) {
  2891.   int c;
  2892.   int j=0;
  2893.   do {
  2894.     c=fgetc(fp);
  2895.     if (c!=EOF) {
  2896.       switch(c) {
  2897.         case 13: break;  // sauter CR
  2898.         case 10: c=-1; break;
  2899.         case 9: case 12: break;  // sauter ces caractΦres
  2900.         default: s[j++]=(char) c; break;
  2901.       }
  2902.     }
  2903.   }  while((c!=-1) && (c!=EOF) && (j<(max-1)));
  2904.   s[j]='\0';
  2905.   return j;
  2906. }
  2907. int linputsoc(T_SOC soc, char* s, int max) {
  2908.   int c;
  2909.   int j=0;
  2910.   do {
  2911.     unsigned char ch;
  2912.     if (recv(soc, &ch, 1, 0) == 1) {
  2913.       c = ch;
  2914.     } else {
  2915.       c = EOF;
  2916.     }
  2917.     if (c!=EOF) {
  2918.       switch(c) {
  2919.         case 13: break;  // sauter CR
  2920.         case 10: c=-1; break;
  2921.         case 9: case 12: break;  // sauter ces caractΦres
  2922.         default: s[j++]=(char) c; break;
  2923.       }
  2924.     }
  2925.   }  while((c!=-1) && (c!=EOF) && (j<(max-1)));
  2926.   s[j]='\0';
  2927.   return j;
  2928. }
  2929. int linputsoc_t(T_SOC soc, char* s, int max, int timeout) {
  2930.   if (check_readinput_t(soc, timeout)) {
  2931.     return linputsoc(soc, s, max);
  2932.   }
  2933.   return -1;
  2934. }
  2935. int linput_trim(FILE* fp,char* s,int max) {
  2936.   int rlen=0;
  2937.   char* ls=(char*) malloct(max+2);
  2938.   s[0]='\0';
  2939.   if (ls) {
  2940.     char* a;
  2941.     // lire ligne
  2942.     rlen=linput(fp,ls,max);
  2943.     if (rlen) {
  2944.       // sauter espaces et tabs en fin
  2945.       while( (rlen>0) && ((ls[max(rlen-1,0)]==' ') || (ls[max(rlen-1,0)]=='\t')) )
  2946.         ls[--rlen]='\0';
  2947.       // sauter espaces en dΘbut
  2948.       a=ls;
  2949.       while((rlen>0) && ((*a==' ') || (*a=='\t'))) {
  2950.         a++;
  2951.         rlen--;
  2952.       }
  2953.       if (rlen>0) {
  2954.         memcpy(s,a,rlen);      // can copy \0 chars
  2955.         s[rlen]='\0';
  2956.       }
  2957.     }
  2958.     //
  2959.     freet(ls);
  2960.   }
  2961.   return rlen;
  2962. }
  2963. int linput_cpp(FILE* fp,char* s,int max) {
  2964.   int rlen=0;
  2965.   s[0]='\0';
  2966.   do {
  2967.     int ret;
  2968.     if (rlen>0)
  2969.     if (s[rlen-1]=='\\')
  2970.       s[--rlen]='\0';      // couper \ final
  2971.     // lire ligne
  2972.     ret=linput_trim(fp,s+rlen,max-rlen);
  2973.     if (ret>0)
  2974.       rlen+=ret;
  2975.   } while((s[max(rlen-1,0)]=='\\') && (rlen<max));
  2976.   return rlen;
  2977. }
  2978.  
  2979. // idem avec les car spΘciaux
  2980. void rawlinput(FILE* fp,char* s,int max) {
  2981.   int c;
  2982.   int j=0;
  2983.   do {
  2984.     c=fgetc(fp);
  2985.     if (c!=EOF) {
  2986.       switch(c) {
  2987.         case 13: break;  // sauter CR
  2988.         case 10: c=-1; break;
  2989.         default: s[j++]=(char) c; break;
  2990.       }
  2991.     }
  2992.   }  while((c!=-1) && (c!=EOF) && (j<(max-1)));
  2993.   s[j++]='\0';
  2994. }
  2995.  
  2996. //cherche chaine, case insensitive
  2997. char* strstrcase(char *s,char *o) {
  2998.   while((*s) && (strfield(s,o)==0)) s++;
  2999.   if (*s=='\0') return NULL;
  3000.   return s;  
  3001. }
  3002.  
  3003.  
  3004. // Unicode detector
  3005. // See http://www.unicode.org/unicode/reports/tr28/
  3006. // (sect Table 3.1B. Legal UTF-8 Byte Sequences)
  3007. typedef struct {
  3008.   unsigned int pos;
  3009.   unsigned char data[4];
  3010. } t_auto_seq;
  3011.  
  3012. // char between a and b
  3013. #define CHAR_BETWEEN(c, a, b)       ( (c) >= 0x##a ) && ( (c) <= 0x##b )
  3014. // sequence start
  3015. #define SEQBEG                      ( inseq == 0 )
  3016. // in this block
  3017. #define BLK(n,a, b)                 ( (seq.pos >= n) && ((err = CHAR_BETWEEN(seq.data[n], a, b))) )
  3018. #define ELT(n,a)                    BLK(n,a,a)
  3019. // end
  3020. #define SEQEND                      ((ok = 1))
  3021. // sequence started, character will fail if error
  3022. #define IN_SEQ                      ( (inseq = 1) )
  3023. // decoding error
  3024. #define BAD_SEQ                     ( (ok == 0) && (inseq != 0) && (!err) )
  3025. // no sequence started
  3026. #define NO_SEQ                      ( inseq == 0 )
  3027.  
  3028. // is this block an UTF unicode textfile?
  3029. // 0 : no
  3030. // 1 : yes
  3031. // -1: don't know
  3032. int is_unicode_utf8(unsigned char* buffer, unsigned int size) {
  3033.   t_auto_seq seq;
  3034.   unsigned int i;
  3035.   int is_utf=-1;
  3036.  
  3037.   seq.pos=0;
  3038.   for(i=0 ; i < size ; i++) {
  3039.     unsigned int ok=0;
  3040.     unsigned int inseq=0;
  3041.     unsigned int err=0;
  3042.  
  3043.     seq.data[seq.pos]=buffer[i];
  3044.     /**/ if ( SEQBEG && BLK(0,00,7F) && IN_SEQ && SEQEND                                                 ) { }
  3045.     else if ( SEQBEG && BLK(0,C2,DF) && IN_SEQ && BLK(1,80,BF) && SEQEND                                 ) { }
  3046.     else if ( SEQBEG && ELT(0,E0   ) && IN_SEQ && BLK(1,A0,BF) && BLK(2,80,BF) && SEQEND                 ) { }
  3047.     else if ( SEQBEG && BLK(0,E1,EC) && IN_SEQ && BLK(1,80,BF) && BLK(2,80,BF) && SEQEND                 ) { }
  3048.     else if ( SEQBEG && ELT(0,ED   ) && IN_SEQ && BLK(1,80,9F) && BLK(2,80,BF) && SEQEND                 ) { }
  3049.     else if ( SEQBEG && BLK(0,EE,EF) && IN_SEQ && BLK(1,80,BF) && BLK(2,80,BF) && SEQEND                 ) { }
  3050.     else if ( SEQBEG && ELT(0,F0   ) && IN_SEQ && BLK(1,90,BF) && BLK(2,80,BF) && BLK(3,80,BF) && SEQEND ) { }
  3051.     else if ( SEQBEG && BLK(0,F1,F3) && IN_SEQ && BLK(1,80,BF) && BLK(2,80,BF) && BLK(3,80,BF) && SEQEND ) { }
  3052.     else if ( SEQBEG && ELT(0,F4   ) && IN_SEQ && BLK(1,80,8F) && BLK(2,80,BF) && BLK(3,80,BF) && SEQEND ) { }
  3053.     else if ( NO_SEQ ) {    // bad, unknown
  3054.       return 0;
  3055.     }
  3056.     /* */
  3057.     
  3058.     /* Error */
  3059.     if ( BAD_SEQ ) {
  3060.       return 0;
  3061.     }
  3062.  
  3063.     /* unicode character */
  3064.     if (seq.pos > 0)
  3065.       is_utf=1;
  3066.  
  3067.     /* Next */
  3068.     if (ok)
  3069.       seq.pos=0;
  3070.     else
  3071.       seq.pos++;
  3072.  
  3073.     /* Internal error */
  3074.     if (seq.pos >= 4)
  3075.       return 0;
  3076.  
  3077.   }
  3078.  
  3079.   return is_utf;
  3080. }
  3081.  
  3082. void map_characters(unsigned char* buffer, unsigned int size, unsigned int* map) {
  3083.   unsigned int i;
  3084.   memset(map, 0, sizeof(unsigned int) * 256);
  3085.   for(i = 0 ; i < size ; i++) {
  3086.     map[buffer[i]]++;
  3087.   }
  3088. }
  3089.  
  3090.  
  3091. // le fichier est-il un fichier html?
  3092. //  0 : non
  3093. //  1 : oui
  3094. // -1 : on sait pas
  3095. // -2 : on sait pas, pas d'extension
  3096. int ishtml(httrackp *opt,const char* fil) {
  3097.   /* User-defined MIME types (overrides ishtml()) */
  3098.   char BIGSTK fil_noquery[HTS_URLMAXSIZE*2];
  3099.   char mime[256];
  3100.   char* a;
  3101.   strcpybuff(fil_noquery, fil);
  3102.   if ((a = strchr(fil_noquery, '?')) != NULL) {
  3103.     *a = '\0';
  3104.   }
  3105.   if (get_userhttptype(opt, mime, fil_noquery)) {
  3106.     if (strfield2(mime, "text/html")) {
  3107.       return 1;
  3108.     } else {
  3109.       return 0;
  3110.     }
  3111.   }
  3112.  
  3113.   if (!strnotempty(fil_noquery)) {
  3114.     return -2;
  3115.   }
  3116.  
  3117.   /* Search for known ext */
  3118.   for (a = fil_noquery + strlen(fil_noquery) - 1 ; *a != '.' && *a != '/' && a > fil_noquery ; a-- );
  3119.   if (*a == '.') {  // a une extension
  3120.     char BIGSTK fil_noquery[HTS_URLMAXSIZE*2];
  3121.     char* b;
  3122.     int ret;
  3123.     char* dotted = a;
  3124.     fil_noquery[0]='\0';
  3125.     a++;  // pointer sur extension
  3126.     strncatbuff(fil_noquery,a,HTS_URLMAXSIZE);
  3127.     b=strchr(fil_noquery,'?');
  3128.     if (b)
  3129.       *b='\0';
  3130.     ret = ishtml_ext(fil_noquery);     // retour
  3131.     if (ret == -1) {
  3132.       switch(is_knowntype(opt,dotted)) {
  3133.       case 1:
  3134.         ret = 0;     // connu, non html
  3135.         break;
  3136.       case 2:
  3137.         ret = 1;     // connu, html
  3138.         break;
  3139.       default:
  3140.         ret = -1;    // inconnu..
  3141.         break;
  3142.       }
  3143.     }
  3144.     return ret;
  3145.   } else return -2;   // indΘterminΘ, par exemple /truc
  3146. }
  3147.  
  3148. // idem, mais pour uniquement l'extension
  3149. int ishtml_ext(const char* a) {
  3150.   int html=0;  
  3151.   //
  3152.   if (strfield2(a,"html"))       html = 1;
  3153.   else if (strfield2(a,"htm"))   html = 1;
  3154.   else if (strfield2(a,"shtml")) html = 1;
  3155.   else if (strfield2(a,"phtml")) html = 1;
  3156.   else if (strfield2(a,"htmlx")) html = 1;
  3157.   else if (strfield2(a,"shtm"))  html = 1;
  3158.   else if (strfield2(a,"phtm"))  html = 1;
  3159.   else if (strfield2(a,"htmx"))  html = 1;
  3160.   //
  3161.   // insuccΦs..
  3162.   else {
  3163. #if 1
  3164.     html = -1;    // inconnu..
  3165. #else
  3166.     // XXXXXX not suitable (ext)
  3167.     switch(is_knownext(a)) {
  3168.     case 1:
  3169.       html = 0;     // connu, non html
  3170.       break;
  3171.     case 2:
  3172.       html = 1;     // connu, html
  3173.       break;
  3174.     default:
  3175.       html = -1;    // inconnu..
  3176.       break;
  3177.     }
  3178. #endif
  3179.   }
  3180.   return html;  
  3181. }
  3182.  
  3183. // error (404,500..)
  3184. HTS_INLINE int ishttperror(int err) {
  3185.   switch (err/100) {
  3186.     case 4: case 5: return 1;
  3187.       break;
  3188.   }
  3189.   return 0;
  3190. }
  3191.  
  3192.  
  3193. // retourne le pointeur ou le pointeur + offset si il existe dans la chaine un @ signifiant 
  3194. // une identification
  3195. HTSEXT_API char* jump_identification(const char* source) {
  3196.   const char *a,*trytofind;
  3197.   if (strcmp(source, "file://") == 0)
  3198.       return (char*) source;
  3199.   // rechercher dernier @ (car parfois email transmise dans adresse!)
  3200.   // mais sauter ftp:// Θventuel
  3201.   a = jump_protocol(source);
  3202.   trytofind = strrchr_limit(a, '@', strchr(a,'/'));
  3203.   return (char*) ( (trytofind != NULL) ? trytofind : a );
  3204. }
  3205.  
  3206. HTSEXT_API char* jump_normalized(const char* source) {
  3207.   if (strcmp(source, "file://") == 0)
  3208.       return (char*) source;
  3209.   source = jump_identification(source); 
  3210.   if (strfield(source, "www") && source[3] != '\0') {
  3211.     if (source[3] == '.') {       // www.foo.com -> foo.com
  3212.       source += 4;  
  3213.     } else {                      // www-4.foo.com -> foo.com
  3214.       const char* a = source + 3;
  3215.       while(*a && ( isdigit(*a) || *a == '-') ) a++;
  3216.       if (*a == '.') {
  3217.         source = a + 1;
  3218.       }
  3219.     }
  3220.   }
  3221.   return (char*) source;  
  3222. }
  3223.  
  3224. static int sortNormFnc(const void * a_, const void * b_) {
  3225.   char** a = (char**) a_;
  3226.   char** b = (char**) b_;
  3227.   return strcmp(*a+1, *b+1);
  3228. }
  3229.  
  3230.  
  3231. HTSEXT_API char* fil_normalized(const char* source, char* dest) {
  3232.   char lastc = 0;
  3233.   int gotquery=0;
  3234.   int ampargs=0;
  3235.   int i,j;
  3236.   char* query=NULL;
  3237.   for(i=j=0 ; source[i] != '\0'; i++) {
  3238.     if (!gotquery && source[i] == '?')
  3239.       gotquery=ampargs=1;
  3240.     if ( 
  3241.       (!gotquery && lastc == '/' && source[i] == '/')  // foo//bar -> foo/bar
  3242.       ) {
  3243.     }
  3244.     else {
  3245.       if (gotquery && source[i] == '&') {
  3246.         ampargs++;
  3247.       }
  3248.       dest[j++] = source[i];
  3249.     }
  3250.     lastc = source[i];
  3251.   }
  3252.   dest[j++] = '\0';
  3253.  
  3254.   /* Sort arguments (&foo=1&bar=2 == &bar=2&foo=1) */
  3255.   if (ampargs > 1) {
  3256.     char** amps = malloct(ampargs * sizeof(char*));
  3257.     char* copyBuff = NULL;
  3258.     int qLen=0;
  3259.     assertf(amps != NULL);
  3260.     gotquery = 0;
  3261.     for(i=j=0 ; dest[i] != '\0'; i++) {
  3262.       if ( (gotquery && dest[i] == '&') || ( !gotquery && dest[i] == '?') ) {
  3263.         if (!gotquery) {
  3264.           gotquery=1;
  3265.           query = &dest[i];
  3266.           qLen = (int)strlen(query);
  3267.         }
  3268.         assertf(j < ampargs);
  3269.         amps[j++] = &dest[i];
  3270.         dest[i] = '\0';
  3271.       }
  3272.     }
  3273.     assertf(j == ampargs);
  3274.  
  3275.     /* Sort 'em all */
  3276.     qsort(amps, ampargs, sizeof(char*), sortNormFnc);
  3277.  
  3278.     /* Replace query by sorted query */
  3279.     copyBuff = malloct(qLen + 1);
  3280.     assertf(copyBuff != NULL);
  3281.     copyBuff[0] = '\0';
  3282.     for(i = 0 ; i < ampargs ; i++) {
  3283.       if (i == 0)
  3284.         strcatbuff(copyBuff, "?");
  3285.       else
  3286.         strcatbuff(copyBuff, "&");
  3287.       strcatbuff(copyBuff, amps[i] + 1);
  3288.     }
  3289.     assert((int)strlen(copyBuff) <= qLen);
  3290.     strcpybuff(query, copyBuff);
  3291.  
  3292.     /* Cleanup */
  3293.     freet(amps);
  3294.     freet(copyBuff);
  3295.   }
  3296.   
  3297.   return dest;
  3298. }
  3299.  
  3300. #define endwith(a) ( (len >= (sizeof(a)-1)) ? ( strncmp(dest, a+len-(sizeof(a)-1), sizeof(a)-1) == 0 ) : 0 );
  3301. HTSEXT_API char* adr_normalized(const char* source, char* dest) {
  3302.   /* not yet too aggressive (no com<->net<->org checkings) */
  3303.   strcpybuff(dest, jump_normalized(source));
  3304.   return dest;
  3305. }
  3306. #undef endwith
  3307.  
  3308.  
  3309. // find port (:80) or NULL if not found
  3310. // can handle IPV6 addresses
  3311. HTSEXT_API char* jump_toport(const char* source) {
  3312.   const char *a,*trytofind;
  3313.   a = jump_identification(source);
  3314.   trytofind = strrchr_limit(a, ']', strchr(source, '/'));    // find last ] (http://[3ffe:b80:1234::1]:80/foo.html)
  3315.   a = strchr( (trytofind)?trytofind:a, ':');
  3316.   return (char*)a;
  3317. }
  3318.  
  3319. // strrchr, but not too far
  3320. char* strrchr_limit(const char* s, char c, const char* limit) {
  3321.   if (limit == NULL) {
  3322.     const char* p = strrchr(s, c);
  3323.     return (char*) ( p ? (p+1) : NULL );
  3324.   } else {
  3325.     const char *a = NULL, *p;
  3326.     for(;;) {
  3327.       p = strchr( (a) ? a : s, c);
  3328.       if ((p >= limit) || (p == NULL))
  3329.         return (char*) a;
  3330.       a=p+1;
  3331.     }
  3332.   }
  3333. }
  3334.  
  3335. // strrchr, but not too far
  3336. char* strstr_limit(const char* s, const char* sub, const char* limit) {
  3337.   if (limit == NULL) {
  3338.     return strstr(s, sub);
  3339.   } else {
  3340.     const char* pos = strstr(s, sub);
  3341.     if (pos != NULL) {
  3342.       const char* farpos = strstr(s, limit);
  3343.       if (farpos == NULL || pos < farpos)
  3344.         return (char*) pos;
  3345.     }
  3346.   }
  3347.   return NULL;
  3348. }
  3349.  
  3350. // retourner adr sans ftp://
  3351. HTS_INLINE char* jump_protocol(const char* source) {
  3352.   int p;
  3353.   // scheme
  3354.   // "Comparisons of scheme names MUST be case-insensitive" (RFC2616)
  3355.   if ((p=strfield(source,"http:")))
  3356.     source+=p;
  3357.   else if ((p=strfield(source,"ftp:")))
  3358.     source+=p;
  3359.   else if ((p=strfield(source,"https:")))
  3360.     source+=p;
  3361.   else if ((p=strfield(source,"file:")))
  3362.     source+=p;
  3363. #if HTS_USEMMS
  3364.   else if ((p=strfield(source,"mms:")))
  3365.     source+=p;
  3366. #endif
  3367.   // net_path
  3368.   if (strncmp(source,"//",2)==0)
  3369.     source+=2;
  3370.   return (char*) source;
  3371. }
  3372.  
  3373. // codage base 64 a vers b
  3374. void code64(unsigned char* a,int size_a,unsigned char* b,int crlf) {
  3375.   int i1=0,i2=0,i3=0,i4=0;
  3376.   int loop=0;
  3377.   unsigned long int store;
  3378.   int n;
  3379.   const char _hts_base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  3380.   while(size_a-- > 0) {  
  3381.     // 24 bits
  3382.     n=1; 
  3383.     store = *a++;
  3384.     if (size_a-- > 0) { n=2; store <<= 8; store |= *a++; }
  3385.     if (size_a-- > 0) { n=3; store <<= 8; store |= *a++; }
  3386.     if (n==3) {
  3387.       i4=store & 63;
  3388.       i3=(store>>6) & 63;
  3389.       i2=(store>>12) & 63;
  3390.       i1=(store>>18) & 63;
  3391.     } else if (n==2) {
  3392.       store<<=2;    
  3393.       i3=store & 63;
  3394.       i2=(store>>6) & 63;
  3395.       i1=(store>>12) & 63;
  3396.     } else {
  3397.       store<<=4;
  3398.       i2=store & 63;
  3399.       i1=(store>>6) & 63;
  3400.     }
  3401.     
  3402.     *b++ = _hts_base64[i1];
  3403.     *b++ = _hts_base64[i2];
  3404.     if (n>=2)
  3405.       *b++ = _hts_base64[i3];
  3406.     else
  3407.       *b++ = '=';
  3408.     if (n>=3)
  3409.       *b++ = _hts_base64[i4];
  3410.     else
  3411.       *b++ = '=';
  3412.  
  3413.     if (crlf && ( ( loop += 3 ) % 60) == 0 ) {
  3414.       *b++ = '\r';
  3415.       *b++ = '\n';
  3416.     }
  3417.   }
  3418.   *b++='\0';
  3419. }
  3420.  
  3421. // remplacer " par " etc..
  3422. // buffer MAX 1Ko
  3423. #define strcmpbeg(a, b) strncmp(a, b, strlen(b))
  3424. HTSEXT_API void unescape_amp(char* s) {
  3425.   while(*s) {
  3426.     if (*s=='&') {
  3427.       char* end=strchr(s,';');
  3428.       if ( end && (((int) (end - s)) <= 8) ) {
  3429.         unsigned char c=0;
  3430.         
  3431.         // http://www.w3.org/TR/xhtml-modularization/dtd_module_defs.html
  3432.         if (strcmpbeg(s, "&#") == 0) {
  3433.           int num=0;
  3434.           if ( (s[2] == 'x') || (s[2] == 'X')) {
  3435.             if (sscanf(s+3, "%x", &num) == 1 && num <= 0xff) {
  3436.               c=(unsigned char) num;
  3437.             }
  3438.           } else {
  3439.             if (sscanf(s+2, "%d", &num) == 1 && num <= 0xff) {
  3440.               c=(unsigned char) num;
  3441.             }
  3442.           }
  3443.         }
  3444.         else if (strcmpbeg(s, " ")==0)
  3445.           c=32; // hack - c=160;
  3446.         else if (strcmpbeg(s, "¡")==0)
  3447.           c=161;
  3448.         else if (strcmpbeg(s, "¢")==0)
  3449.           c=162;
  3450.         else if (strcmpbeg(s, "£")==0)
  3451.           c=163;
  3452.         else if (strcmpbeg(s, "¤")==0)
  3453.           c=164;
  3454.         else if (strcmpbeg(s, "¥")==0)
  3455.           c=165;
  3456.         else if (strcmpbeg(s, "¦")==0)
  3457.           c=166;
  3458.         else if (strcmpbeg(s, "§")==0)
  3459.           c=167;
  3460.         else if (strcmpbeg(s, "¨")==0)
  3461.           c=168;
  3462.         else if (strcmpbeg(s, "©")==0)
  3463.           c=169;
  3464.         else if (strcmpbeg(s, "ª")==0)
  3465.           c=170;
  3466.         //else if (strcmpbeg(s, "«")==0)
  3467.         //  c=171;
  3468.         else if (strcmpbeg(s, "¬")==0)
  3469.           c=172;
  3470.         //else if (strcmpbeg(s, "­")==0)
  3471.         //  c=173;
  3472.         else if (strcmpbeg(s, "®")==0)
  3473.           c=174;
  3474.         else if (strcmpbeg(s, "¯")==0)
  3475.           c=175;
  3476.         else if (strcmpbeg(s, "°")==0)
  3477.           c=176;
  3478.         else if (strcmpbeg(s, "±")==0)
  3479.           c=177;
  3480.         else if (strcmpbeg(s, "²")==0)
  3481.           c=178;
  3482.         else if (strcmpbeg(s, "³")==0)
  3483.           c=179;
  3484.         else if (strcmpbeg(s, "´")==0)
  3485.           c=180;
  3486.         else if (strcmpbeg(s, "µ")==0)
  3487.           c=181;
  3488.         else if (strcmpbeg(s, "¶")==0)
  3489.           c=182;
  3490.         else if (strcmpbeg(s, "·")==0)
  3491.           c=183;
  3492.         else if (strcmpbeg(s, "¸")==0)
  3493.           c=184;
  3494.         else if (strcmpbeg(s, "¹")==0)
  3495.           c=185;
  3496.         else if (strcmpbeg(s, "º")==0)
  3497.           c=186;
  3498.         //else if (strcmpbeg(s, "»")==0)
  3499.         //  c=187;
  3500.         else if (strcmpbeg(s, "¼")==0)
  3501.           c=188;
  3502.         else if (strcmpbeg(s, "½")==0)
  3503.           c=189;
  3504.         else if (strcmpbeg(s, "¾")==0)
  3505.           c=190;
  3506.         else if (strcmpbeg(s, "¿")==0)
  3507.           c=191;
  3508.         else if (strcmpbeg(s, "À")==0)
  3509.           c=192;
  3510.         else if (strcmpbeg(s, "Á")==0)
  3511.           c=193;
  3512.         else if (strcmpbeg(s, "Â")==0)
  3513.           c=194;
  3514.         else if (strcmpbeg(s, "Ã")==0)
  3515.           c=195;
  3516.         else if (strcmpbeg(s, "Ä")==0)
  3517.           c=196;
  3518.         else if (strcmpbeg(s, "Å")==0)
  3519.           c=197;
  3520.         else if (strcmpbeg(s, "Æ")==0)
  3521.           c=198;
  3522.         else if (strcmpbeg(s, "Ç")==0)
  3523.           c=199;
  3524.         else if (strcmpbeg(s, "È")==0)
  3525.           c=200;
  3526.         else if (strcmpbeg(s, "É")==0)
  3527.           c=201;
  3528.         else if (strcmpbeg(s, "Ê")==0)
  3529.           c=202;
  3530.         else if (strcmpbeg(s, "Ë")==0)
  3531.           c=203;
  3532.         else if (strcmpbeg(s, "Ì")==0)
  3533.           c=204;
  3534.         else if (strcmpbeg(s, "Í")==0)
  3535.           c=205;
  3536.         else if (strcmpbeg(s, "Î")==0)
  3537.           c=206;
  3538.         else if (strcmpbeg(s, "Ï")==0)
  3539.           c=207;
  3540.         else if (strcmpbeg(s, "Ð")==0)
  3541.           c=208;
  3542.         else if (strcmpbeg(s, "Ñ")==0)
  3543.           c=209;
  3544.         else if (strcmpbeg(s, "Ò")==0)
  3545.           c=210;
  3546.         else if (strcmpbeg(s, "Ó")==0)
  3547.           c=211;
  3548.         else if (strcmpbeg(s, "Ô")==0)
  3549.           c=212;
  3550.         else if (strcmpbeg(s, "Õ")==0)
  3551.           c=213;
  3552.         else if (strcmpbeg(s, "Ö")==0)
  3553.           c=214;
  3554.         else if (strcmpbeg(s, "×")==0)
  3555.           c=215;
  3556.         else if (strcmpbeg(s, "Ø")==0)
  3557.           c=216;
  3558.         else if (strcmpbeg(s, "Ù")==0)
  3559.           c=217;
  3560.         else if (strcmpbeg(s, "Ú")==0)
  3561.           c=218;
  3562.         else if (strcmpbeg(s, "Û")==0)
  3563.           c=219;
  3564.         else if (strcmpbeg(s, "Ü")==0)
  3565.           c=220;
  3566.         else if (strcmpbeg(s, "Ý")==0)
  3567.           c=221;
  3568.         else if (strcmpbeg(s, "Þ")==0)
  3569.           c=222;
  3570.         else if (strcmpbeg(s, "ß")==0)
  3571.           c=223;
  3572.         else if (strcmpbeg(s, "à")==0)
  3573.           c=224;
  3574.         else if (strcmpbeg(s, "á")==0)
  3575.           c=225;
  3576.         else if (strcmpbeg(s, "â")==0)
  3577.           c=226;
  3578.         else if (strcmpbeg(s, "ã")==0)
  3579.           c=227;
  3580.         else if (strcmpbeg(s, "ä")==0)
  3581.           c=228;
  3582.         else if (strcmpbeg(s, "å")==0)
  3583.           c=229;
  3584.         else if (strcmpbeg(s, "æ")==0)
  3585.           c=230;
  3586.         else if (strcmpbeg(s, "ç")==0)
  3587.           c=231;
  3588.         else if (strcmpbeg(s, "è")==0)
  3589.           c=232;
  3590.         else if (strcmpbeg(s, "é")==0)
  3591.           c=233;
  3592.         else if (strcmpbeg(s, "ê")==0)
  3593.           c=234;
  3594.         else if (strcmpbeg(s, "ë")==0)
  3595.           c=235;
  3596.         else if (strcmpbeg(s, "ì")==0)
  3597.           c=236;
  3598.         else if (strcmpbeg(s, "í")==0)
  3599.           c=237;
  3600.         else if (strcmpbeg(s, "î")==0)
  3601.           c=238;
  3602.         else if (strcmpbeg(s, "ï")==0)
  3603.           c=239;
  3604.         else if (strcmpbeg(s, "ð")==0)
  3605.           c=240;
  3606.         else if (strcmpbeg(s, "ñ")==0)
  3607.           c=241;
  3608.         else if (strcmpbeg(s, "ò")==0)
  3609.           c=242;
  3610.         else if (strcmpbeg(s, "ó")==0)
  3611.           c=243;
  3612.         else if (strcmpbeg(s, "ô")==0)
  3613.           c=244;
  3614.         else if (strcmpbeg(s, "õ")==0)
  3615.           c=245;
  3616.         else if (strcmpbeg(s, "ö")==0)
  3617.           c=246;
  3618.         else if (strcmpbeg(s, "÷")==0)
  3619.           c=247;
  3620.         else if (strcmpbeg(s, "ø")==0)
  3621.           c=248;
  3622.         else if (strcmpbeg(s, "ù")==0)
  3623.           c=249;
  3624.         else if (strcmpbeg(s, "ú")==0)
  3625.           c=250;
  3626.         else if (strcmpbeg(s, "û")==0)
  3627.           c=251;
  3628.         else if (strcmpbeg(s, "ü")==0)
  3629.           c=252;
  3630.         else if (strcmpbeg(s, "ý")==0)
  3631.           c=253;
  3632.         else if (strcmpbeg(s, "þ")==0)
  3633.           c=254;
  3634.         else if (strcmpbeg(s, "ÿ")==0)
  3635.           c=255;
  3636.         //        
  3637.         else if (strcmpbeg(s,"&")==0)
  3638.           c='&';
  3639.         else if (strcmpbeg(s,">")==0)
  3640.           c='>';
  3641.         else if (strcmpbeg(s,"«")==0)
  3642.           c='\"';
  3643.         else if (strcmpbeg(s,"<")==0)
  3644.           c='<';
  3645.         else if (strcmpbeg(s," ")==0)
  3646.           c=' ';
  3647.         else if (strcmpbeg(s,""")==0)
  3648.           c='\"';
  3649.         else if (strcmpbeg(s,"»")==0)
  3650.           c='\"';
  3651.         else if (strcmpbeg(s,"­")==0)
  3652.           c='-';
  3653.         else if (strcmpbeg(s,"˜")==0)
  3654.           c='~';
  3655.         // remplacer?
  3656.         if (c) {
  3657.           char BIGSTK buff[HTS_URLMAXSIZE*2];
  3658.           buff[0]=(char) c;
  3659.           strcpybuff(buff+1,end+1);
  3660.           strcpybuff(s,buff);
  3661.         }
  3662.       }
  3663.     }
  3664.     s++;
  3665.   }
  3666. }
  3667.  
  3668. static int ehexh(char c) {
  3669.   if ((c>='0') && (c<='9')) return c-'0';
  3670.   if ((c>='a') && (c<='f')) c-=('a'-'A');
  3671.   if ((c>='A') && (c<='F')) return (c-'A'+10);
  3672.   return 0;
  3673. }
  3674.  
  3675. static int ehex(const char* s) {
  3676.   return 16*ehexh(*s)+ehexh(*(s+1));
  3677. }
  3678.  
  3679. // remplacer %20 par ' ', | par : etc..
  3680. // buffer MAX 1Ko
  3681. HTSEXT_API char* unescape_http(char *catbuff, const char* s) {
  3682.   int i,j=0;
  3683.   for (i=0;i<(int) strlen(s);i++) {
  3684.     if (s[i]=='%') {
  3685.       i++;
  3686.       catbuff[j++]=(char) ehex(s+i);
  3687.       i++;    // sauter 2 caractΦres finalement
  3688.     }
  3689.     /*
  3690.     NON a cause de trucs comme /home/0,1837,1|7|1173|Content,00.html
  3691.     else if (s[i]=='|') {                     // exemple: file:///C|Program%20Files...
  3692.       tempo[j++]=':';
  3693.     }
  3694.     */
  3695.     else
  3696.       catbuff[j++]=s[i];
  3697.   }
  3698.   catbuff[j++]='\0';
  3699.   return catbuff;
  3700. }
  3701.  
  3702. // unescape in URL/URI ONLY what has to be escaped, to form a standard URL/URI
  3703. // DOES NOT DECODE %25
  3704. HTSEXT_API char* unescape_http_unharm(char *catbuff, const char* s, int no_high) {
  3705.   int i,j=0;
  3706.   for (i=0;i<(int) strlen(s);i++) {
  3707.     if (s[i]=='%') {
  3708.       int nchar=(char) ehex(s+i+1);
  3709.  
  3710.       int test = (  CHAR_RESERVED(nchar)
  3711.                 || ( nchar != '%' && CHAR_DELIM(nchar) )
  3712.                 || CHAR_UNWISE(nchar)
  3713.                 || CHAR_LOW(nchar)        /* CHAR_SPECIAL */
  3714.                 || CHAR_XXAVOID(nchar) 
  3715.                 || (
  3716.                   (no_high)
  3717.                   &&
  3718.                   CHAR_HIG(nchar)
  3719.                 )
  3720.                 );
  3721.  
  3722.       if (!test) {
  3723.         catbuff[j++]=(char) ehex(s+i+1);
  3724.         i+=2;
  3725.       } else {
  3726.         catbuff[j++]='%';
  3727.       }
  3728.     }
  3729.     /*
  3730.     NON a cause de trucs comme /home/0,1837,1|7|1173|Content,00.html
  3731.     else if (s[i]=='|') {                     // exemple: file:///C|Program%20Files...
  3732.       tempo[j++]=':';
  3733.     }
  3734.     */
  3735.     else
  3736.       catbuff[j++]=s[i];
  3737.   }
  3738.   catbuff[j++]='\0';
  3739.   return catbuff;
  3740. }
  3741.  
  3742. // remplacer " par %xx etc..
  3743. // buffer MAX 1Ko
  3744. HTSEXT_API void escape_spc_url(char* s) {
  3745.   x_escape_http(s,2);
  3746. }
  3747. // smith / john -> smith%20%2f%20john
  3748. HTSEXT_API void escape_in_url(char* s) {
  3749.   x_escape_http(s,1);
  3750. }
  3751. // smith / john -> smith%20/%20john
  3752. HTSEXT_API void escape_uri(char* s) {
  3753.   x_escape_http(s,3);
  3754. }
  3755. HTSEXT_API void escape_uri_utf(char* s) {
  3756.   x_escape_http(s,30);
  3757. }
  3758. HTSEXT_API void escape_check_url(char* s) {
  3759.   x_escape_http(s,0);
  3760. }
  3761. // same as escape_check_url, but returns char*
  3762. HTSEXT_API char* escape_check_url_addr(char *catbuff, const char* s) {
  3763.   char* adr;
  3764.   escape_check_url(adr = concat(catbuff, s, ""));
  3765.   return adr;
  3766. }
  3767.  
  3768. // strip all control characters
  3769. HTSEXT_API void escape_remove_control(char* s) {
  3770.   unsigned char* ss = (unsigned char*) s;
  3771.   while(*ss) {
  3772.     if (*ss < 32) {    /* CONTROL characters go away! */
  3773.       char BIGSTK tmp[HTS_URLMAXSIZE*2];
  3774.       strcpybuff(tmp, ss+1);
  3775.       strcpybuff(ss, tmp);
  3776.     } else {
  3777.       ss++;
  3778.     }
  3779.   }
  3780. }
  3781.  
  3782. HTSEXT_API void x_escape_html(char* s) {
  3783.   while(*s) {
  3784.     int test=0;
  3785.       test = (
  3786.                 CHAR_HIG(*s)
  3787.              || CHAR_XXAVOID(*s) );
  3788.  
  3789.     if (test) {
  3790.       char BIGSTK buffer[HTS_URLMAXSIZE*3];
  3791.       int n;
  3792.       n = (int)(unsigned char) *s;
  3793.       strcpybuff(buffer, s+1);
  3794.       sprintf(s,"&#x%02x;", n);
  3795.       strcatbuff(s, buffer);
  3796.     }
  3797.     s++;
  3798.   }
  3799. }
  3800.  
  3801.  
  3802. HTSEXT_API void x_escape_http(char* s,int mode) {
  3803.   while(*s) {
  3804.     int test=0;
  3805.     if (mode == 0)
  3806.       test=(strchr("\" ",*s)!=0);
  3807.     else if (mode==1) {
  3808.       test = (  CHAR_RESERVED(*s)
  3809.              || CHAR_DELIM(*s)
  3810.              || CHAR_UNWISE(*s)
  3811.              || CHAR_SPECIAL(*s)
  3812.              || CHAR_XXAVOID(*s)
  3813.              || CHAR_MARK(*s));
  3814.     }
  3815.     else if (mode==2)
  3816.       test=(*s == ' ');           // n'escaper que espace
  3817.     else if (mode==3) {                   // Θchapper que ce qui est nΘcessaire
  3818.       test = (
  3819.                 CHAR_SPECIAL(*s)
  3820.              || CHAR_XXAVOID(*s) );
  3821.     }
  3822.     else if (mode==30) {                   // Θchapper que ce qui est nΘcessaire
  3823.       test = (
  3824.                 CHAR_LOW(*s)
  3825.              || CHAR_XXAVOID(*s) );
  3826.     }
  3827.  
  3828.     if (test) {
  3829.       char BIGSTK buffer[HTS_URLMAXSIZE*3];
  3830.       int n;
  3831.       n=(int)(unsigned char) *s;
  3832.       strcpybuff(buffer,s+1);
  3833.       sprintf(s,"%%%02x",n);
  3834.       strcatbuff(s,buffer);
  3835.     }
  3836.     s++;
  3837.   }
  3838. }
  3839.  
  3840. HTSEXT_API void escape_for_html_print(char* s, char* d) {
  3841.   for( ; *s ; s++) {
  3842.     if (*s == '&') {
  3843.       strcpybuff(d, "&");
  3844.       d += strlen(d);
  3845.     } else {
  3846.       *d++ = *s;
  3847.     }
  3848.   }
  3849.   *d = '\0';
  3850. }
  3851.  
  3852. HTSEXT_API void escape_for_html_print_full(char* s, char* d) {
  3853.   for( ; *s ; s++) {
  3854.     if (*s == '&') {
  3855.       strcpybuff(d, "&");
  3856.       d += strlen(d);
  3857.     } else if (CHAR_HIG(*s)) {
  3858.       sprintf(d, "&#x%02x;", (unsigned char) *s);
  3859.       d += strlen(d);
  3860.     } else {
  3861.       *d++ = *s;
  3862.     }
  3863.   }
  3864.   *d = '\0';
  3865. }
  3866.  
  3867. // concat, concatΦne deux chaines et renvoi le rΘsultat
  3868. // permet d'allΘger grandement le code
  3869. // il faut savoir qu'on ne peut mettre plus de 16 concat() dans une expression
  3870. HTSEXT_API char* concat(char *catbuff,const char* a,const char* b) {
  3871.     if (a != NULL && a[0] != '\0') {
  3872.         strcpybuff(catbuff, a);
  3873.     } else {
  3874.         catbuff[0] = '\0';
  3875.     }
  3876.     if (b != NULL && b[0] != '\0') {
  3877.         strcatbuff(catbuff, b);
  3878.     }
  3879.   return catbuff;
  3880. }
  3881. // conversion fichier / -> antislash
  3882. static char* __fconv(char* a) {
  3883. #if HTS_DOSNAME
  3884.   int i;
  3885.   for(i = 0 ; a[i] != 0 ; i++)
  3886.     if (a[i] == '/')  // Unix-to-DOS style
  3887.       a[i] = '\\';
  3888. #endif
  3889.   return a;
  3890. }
  3891.  
  3892. HTSEXT_API char* fconcat(char *catbuff, const char* a, const char* b) {
  3893.   return __fconv(concat(catbuff,a,b));
  3894. }
  3895. HTSEXT_API char* fconv(char *catbuff, const char* a) {
  3896.   return __fconv(concat(catbuff,a,""));
  3897. }
  3898.  
  3899. /* / et \\ en / */
  3900. static char* __fslash(char* a) {
  3901.   int i;
  3902.   for(i = 0 ; a[i] != 0 ; i++)
  3903.     if (a[i] == '\\')  // convertir
  3904.       a[i] = '/';
  3905.   return a;
  3906. }
  3907. char* fslash(char *catbuff, const char* a) {
  3908.   return __fslash(concat(catbuff,a,NULL));
  3909. }
  3910.  
  3911. // conversion minuscules, avec buffer
  3912. char* convtolower(char *catbuff, const char* a) {
  3913.   strcpybuff(catbuff,a);
  3914.   hts_lowcase(catbuff);  // lower case
  3915.   return catbuff;
  3916. }
  3917.  
  3918. // conversion en minuscules
  3919. void hts_lowcase(char* s) {
  3920.   int i;
  3921.   for(i=0;i<(int) strlen(s);i++)
  3922.     if ((s[i]>='A') && (s[i]<='Z'))
  3923.       s[i]+=('a'-'A');
  3924. }
  3925.  
  3926. // remplacer un caractΦre d'une chaεne dans une autre
  3927. HTS_INLINE void hts_replace(char *s,char from,char to) { 
  3928.   char* a;
  3929.   while ((a=strchr(s,from))!=NULL) {
  3930.     *a=to;
  3931.   }
  3932. }
  3933.  
  3934.  
  3935. // caractΦre espace, guillemets, CR, LF etc..
  3936. /* SECTION OPTIMISEE:
  3937.   #define  is_space(c) (strchr(" \"\x0d\x0a\x09'",c)!=NULL)
  3938.   #define  is_realspace(c) (strchr(" \x0d\x0a\x09\x0c",c)!=NULL)
  3939. */
  3940. /*
  3941. HTS_INLINE int is_space(char c) {
  3942.   if (c==' ')  return 1;  // spc
  3943.   if (c=='"')  return 1;  // quote
  3944.   if (c==10)   return 1;  // lf
  3945.   if (c==13)   return 1;  // cr
  3946.   if (c=='\'') return 1;  // quote
  3947.   //if (c=='`')  return 1;  // backquote      << non
  3948.   if (c==9)    return 1;  // tab
  3949.   return 0;
  3950. }
  3951. */
  3952.  
  3953. // caractΦre espace, CR, LF, TAB
  3954. /*
  3955. HTS_INLINE int is_realspace(char c) {
  3956.   if (c==' ')  return 1;  // spc
  3957.   if (c==10)   return 1;  // lf
  3958.   if (c==13)   return 1;  // cr
  3959.   if (c==9)    return 1;  // tab
  3960.   return 0;
  3961. }
  3962. */
  3963.  
  3964.  
  3965.  
  3966.  
  3967.  
  3968. // deviner type d'un fichier local..
  3969. // ex: fil="toto.gif" -> s="image/gif"
  3970. void guess_httptype(httrackp *opt,char *s,const char *fil) {
  3971.   get_httptype(opt,s, fil, 1);
  3972. }
  3973. // idem
  3974. // flag: 1 si toujours renvoyer un type
  3975. HTSEXT_API void get_httptype(httrackp *opt,char *s,const char *fil,int flag) {
  3976.   // userdef overrides get_httptype
  3977.   if (get_userhttptype(opt, s, fil)) {
  3978.     return ;
  3979.   }
  3980.   // regular tests
  3981.   if (ishtml(opt,fil) == 1) {
  3982.     strcpybuff(s,"text/html");
  3983.   } else {
  3984.     /* Check html -> text/html */
  3985.     const char* a = fil + strlen(fil) - 1;    
  3986.     while ( (*a!='.') && (*a!='/') && (a>fil)) a--;
  3987.     if (*a=='.' && strlen(a) < 32) {
  3988.       int j=0;
  3989.       a++;
  3990.       while(strnotempty(hts_mime[j][1])) {
  3991.         if (strfield2(hts_mime[j][1],a)) {
  3992.           if (hts_mime[j][0][0]!='*') {    // Une correspondance existe
  3993.             strcpybuff(s,hts_mime[j][0]);
  3994.             return;
  3995.           }
  3996.         }
  3997.         j++;
  3998.       }
  3999.       
  4000.       if (flag)
  4001.         sprintf(s,"application/%s",a);
  4002.     } else {
  4003.       if (flag)
  4004.         strcpybuff(s,"application/octet-stream");
  4005.     }
  4006.   }
  4007. }
  4008.  
  4009. // get type of fil (php)
  4010. // s: buffer (text/html) or NULL
  4011. // return: 1 if known by user
  4012. int get_userhttptype(httrackp *opt, char *s, const char *fil) {
  4013.   if (s != NULL) {
  4014.     if (s)
  4015.       s[0]='\0';
  4016.     if (fil == NULL || *fil == '\0')
  4017.       return 0;
  4018. #if 1
  4019.     if (StringLength(opt->mimedefs) > 0) {
  4020.  
  4021.       /* Check --assume foooo/foo/bar.cgi=text/html, then foo/bar.cgi=text/html, then bar.cgi=text/html */
  4022.       /* also: --assume baz,bar,foooo/foo/bar.cgi=text/html */
  4023.       /* start from path begining */
  4024.       do {
  4025.         const char* next;
  4026.         const char* mimedefs = StringBuff(opt->mimedefs);    /* loop through mime definitions : \nfoo=bar\nzoo=baz\n.. */
  4027.         while(*mimedefs != '\0') {
  4028.           const char* segment = fil + 1;
  4029.           if (*mimedefs == '\n') {
  4030.             mimedefs++;
  4031.           }
  4032.           /* compare current segment with user's definition */
  4033.           do {
  4034.             int i;
  4035.             /* check current item */
  4036.             for(i = 0 ; 
  4037.               mimedefs[i] != '\0'           /* end of all defs */
  4038.               && mimedefs[i] != ' '         /* next item in left list */
  4039.               && mimedefs[i] != '='         /* end of left list */
  4040.               && mimedefs[i] != '\n'        /* end of this def (?) */
  4041.               && mimedefs[i] == segment[i]  /* same item */
  4042.               ; i++);
  4043.             /* success */
  4044.             if ( ( mimedefs[i] == '=' || mimedefs[i] == ' ' ) && segment[i] == '\0') {
  4045.               int i2;
  4046.               while(mimedefs[i] != 0 && mimedefs[i] != '\n' && mimedefs[i] != '=') i++;
  4047.               if (mimedefs[i] == '=') {
  4048.                 i++;
  4049.                 for(i2 = 0 ; mimedefs[i + i2] != '\n' && mimedefs[i + i2] != '\0' ; i2++) {
  4050.                   s[i2] = mimedefs[i + i2];
  4051.                 }
  4052.                 s[i2] = '\0';
  4053.                 return 1;   /* SUCCESS! */
  4054.               }
  4055.             }
  4056.             /* next item in list */
  4057.             for(mimedefs += i ; 
  4058.               *mimedefs != '\0' && *mimedefs != '\n' && *mimedefs != '=' && *mimedefs != ' ' ; 
  4059.               mimedefs++);
  4060.             if (*mimedefs == ' ') {
  4061.               mimedefs++;
  4062.             }
  4063.           } while(*mimedefs != '\0' && *mimedefs != '\n' && *mimedefs != '=');
  4064.           /* next user-def */
  4065.           for( ; *mimedefs != '\0' && *mimedefs != '\n' ; mimedefs++);
  4066.         }
  4067.         /* shorten segment */
  4068.         next = strchr(fil + 1, '/');
  4069.         if (next == NULL) {
  4070.           /* ext tests */
  4071.           next = strchr(fil + 1, '.');
  4072.         }
  4073.         fil = next;
  4074.       } while(fil != NULL);
  4075.     }
  4076. #else
  4077.     if (*buffer) {
  4078.       char BIGSTK search[1024];
  4079.       char* detect;
  4080.  
  4081.  
  4082.       sprintf(search,"\n%s=",ext);    // php=text/html
  4083.       detect=strstr(*buffer,search);
  4084.       if (!detect) {
  4085.         sprintf(search,"\n%s\n",ext); // php\ncgi=text/html
  4086.         detect=strstr(*buffer,search);
  4087.       }
  4088.       if (detect) {
  4089.         detect=strchr(detect,'=');
  4090.         if (detect) {
  4091.           detect++;
  4092.           if (s) {
  4093.             char* a;
  4094.             a=strchr(detect,'\n');
  4095.             if (a) {
  4096.               strncatbuff(s,detect,(int) (a - detect));
  4097.             }
  4098.           }
  4099.           return 1;
  4100.         }
  4101.       }
  4102.     }
  4103. #endif
  4104.   }
  4105.   return 0;
  4106. }
  4107. // renvoyer extesion d'un type mime..
  4108. // ex: "image/gif" -> gif
  4109. void give_mimext(char *s,const char *st) {   
  4110.   int ok=0;
  4111.   int j=0;
  4112.   s[0]='\0';
  4113.   while( (!ok) && (strnotempty(hts_mime[j][1])) ) {
  4114.     if (strfield2(hts_mime[j][0],st)) {
  4115.       if (hts_mime[j][1][0]!='*') {    // Une correspondance existe
  4116.         strcpybuff(s,hts_mime[j][1]);
  4117.         ok=1;
  4118.       }
  4119.     }
  4120.     j++;
  4121.   }
  4122.   // wrap "x" mimetypes, such as:
  4123.   // application/x-mp3
  4124.   // or
  4125.   // application/mp3
  4126.   if (!ok) {
  4127.     int p;
  4128.     const char* a=NULL;
  4129.     if ((p=strfield(st,"application/x-")))
  4130.       a=st+p;
  4131.     else if ((p=strfield(st,"application/")))
  4132.       a=st+p;
  4133.     if (a) {
  4134.       if ((int)strlen(a) >= 1) {
  4135.         if ((int)strlen(a) <= 4) {
  4136.           strcpybuff(s,a);
  4137.           ok=1;
  4138.         }
  4139.       }
  4140.     }
  4141.   }
  4142. }
  4143. // extension connue?..
  4144. //  0 : non
  4145. //  1 : oui
  4146. //  2 : html
  4147. HTSEXT_API int is_knowntype(httrackp *opt,const char *fil) {
  4148.     char catbuff[CATBUFF_SIZE];
  4149.   const char *ext;
  4150.   int j=0;
  4151.   if (!fil)
  4152.     return 0;
  4153.   ext = get_ext(catbuff, fil);
  4154.   while(strnotempty(hts_mime[j][1])) {
  4155.     if (strfield2(hts_mime[j][1], ext)) {
  4156.       if (strfield2(hts_mime[j][0], "text/html"))
  4157.         return 2;
  4158.       else
  4159.         return 1;
  4160.     }
  4161.     j++;
  4162.   }
  4163.  
  4164.   // Known by user?
  4165.   return (is_userknowntype(opt,fil));
  4166. }
  4167. // extension : html,gif..
  4168. HTSEXT_API char* get_ext(char *catbuff, const char *fil) {
  4169.   const char *a=fil+strlen(fil)-1;    
  4170.  
  4171.   while ( (*a!='.') && (*a!='/')  && (a>fil)) a--;
  4172.   if (*a=='.') {
  4173.         char fil_noquery[HTS_URLMAXSIZE*2];
  4174.     char* b;
  4175.     fil_noquery[0]='\0';
  4176.     a++;  // pointer sur extension
  4177.     strncatbuff(fil_noquery,a,HTS_URLMAXSIZE);
  4178.     b=strchr(fil_noquery,'?');
  4179.     if (b)
  4180.       *b='\0';
  4181.     return concat(catbuff,fil_noquery,"");
  4182.   }
  4183.   else
  4184.     return "";
  4185. }
  4186. // known type?..
  4187. //  0 : no
  4188. //  1 : yes
  4189. //  2 : html
  4190. // setdefs : set mime buffer:
  4191. //   file=(char*) "asp=text/html\nphp=text/html\n"
  4192. HTSEXT_API int is_userknowntype(httrackp *opt,const char *fil) {
  4193.   char BIGSTK mime[1024];
  4194.   if (!fil)
  4195.     return 0;
  4196.   if (!strnotempty(fil))
  4197.     return 0;
  4198.   mime[0]='\0';
  4199.   get_userhttptype(opt, mime, fil);
  4200.   if (!strnotempty(mime))
  4201.     return 0;
  4202.   else if (strfield2(mime,"text/html"))
  4203.     return 2;
  4204.   else
  4205.     return 1;
  4206. }
  4207.  
  4208. // page dynamique?
  4209. // is_dyntype(get_ext("foo.asp"))
  4210. HTSEXT_API int is_dyntype(const char *fil) {
  4211.   int j=0;
  4212.   if (!fil)
  4213.     return 0;
  4214.   if (!strnotempty(fil))
  4215.     return 0;
  4216.   while(strnotempty(hts_ext_dynamic[j])) {
  4217.     if (strfield2(hts_ext_dynamic[j],fil)) {
  4218.       return 1;
  4219.     }
  4220.     j++;
  4221.   }
  4222.   return 0;
  4223. }
  4224.  
  4225. // types critiques qui ne doivent pas Ωtre changΘs car renvoyΘs par des serveurs qui ne
  4226. // connaissent pas le type
  4227. int may_unknown(httrackp *opt,const char* st) {
  4228.   int j=0;
  4229.   // types mΘdia
  4230.   if (may_be_hypertext_mime(opt,st, "")) {
  4231.     return 1;
  4232.   }
  4233.   while(strnotempty(hts_mime_keep[j])) {
  4234.     if (strfield2(hts_mime_keep[j],st)) {      // trouvΘ
  4235.       return 1;
  4236.     }
  4237.     j++;
  4238.   }    
  4239.   return 0;
  4240. }
  4241.  
  4242. /* returns 1 if the mime/filename seems to be bogus because of badly recognized multiple extension
  4243.   ; such as "application/x-wais-source" for "httrack-3.42-1.el5.src.rpm"
  4244.   reported by Hippy Dave 08/2008 (3.43) */
  4245. int may_bogus_multiple(httrackp *opt, const char* mime, const char *filename) {
  4246.   int j;
  4247.   for(j = 0 ; strnotempty(hts_mime_keep[j]) ; j++) {
  4248.     if (strfield2(hts_mime_bogus_multiple[j], mime)) {      /* found mime type in suspicious list */
  4249.       char ext[64];
  4250.       ext[0] = '\0';
  4251.       give_mimext(ext, mime);
  4252.       if (ext[0] != 0) {   /* we have an extension for that */
  4253.         const size_t ext_size = strlen(ext);
  4254.         const char *file = strrchr(filename, '/');  /* fetch terminal filename */
  4255.         if (file != NULL) {
  4256.           int i;
  4257.           for(i = 0 ; file[i] != 0 ; i++) {
  4258.             if (i > 0 && file[i - 1] == '.' && strncasecmp(&file[i], ext, ext_size) == 0 
  4259.               && ( file[i + ext_size] == 0 || file[i + ext_size] == '.' || file[i + ext_size] == '?' ) ) {
  4260.               return 1;  /* is ambiguous */
  4261.             }
  4262.           }
  4263.         }
  4264.       }
  4265.       return 0;
  4266.     }
  4267.   }    
  4268.   return 0;
  4269. }
  4270.  
  4271. /* filename extension should not be changed because potentially bogus ; replaces may_unknown() (3.43) */
  4272. int may_unknown2(httrackp *opt, const char* mime, const char *filename) {
  4273.   int ret = may_unknown(opt, mime);
  4274.   if (ret == 0) {
  4275.     ret = may_bogus_multiple(opt, mime, filename);
  4276.   }
  4277.   return ret;
  4278. }
  4279.  
  4280. // -- Utils fichiers
  4281.  
  4282. // pretty print for i/o
  4283. void fprintfio(FILE* fp,char* buff,char* prefix) {
  4284.   char nl=1;
  4285.   while(*buff) {
  4286.     switch(*buff) {
  4287.     case 13: break;
  4288.     case 10:
  4289.       fprintf(fp,"\r\n");
  4290.       nl=1;
  4291.     break;
  4292.     default:
  4293.       if (nl)
  4294.         fprintf(fp,prefix);
  4295.       nl=0;
  4296.       fputc(*buff,fp);
  4297.     }
  4298.     buff++;
  4299.   }
  4300. }
  4301.  
  4302. /* Le fichier existe-t-il? (ou est-il accessible?) */
  4303. int fexist(const char* s) {
  4304.     char catbuff[CATBUFF_SIZE];
  4305.   struct stat st;
  4306.   memset(&st, 0, sizeof(st));
  4307.   if (stat(fconv(catbuff,s), &st) == 0) {
  4308.     if (S_ISREG(st.st_mode)) {
  4309.       return 1;
  4310.     }
  4311.   }
  4312.   return 0;
  4313. } 
  4314.  
  4315. /* Taille d'un fichier, -1 si n'existe pas */
  4316. /* fp->_cnt ne fonctionne pas sur toute les plate-formes :-(( */
  4317. /* Note: NOT YET READY FOR 64-bit */
  4318. off_t fsize(const char* s) {
  4319.     char catbuff[CATBUFF_SIZE];
  4320.     FILE* fp;
  4321.   if (strnotempty(s)==0)     // nom vide: erreur
  4322.     return -1;
  4323.   fp=fopen(fconv(catbuff,s),"rb");
  4324.   if (fp!=NULL) {
  4325.     off_t i;
  4326.     fseek(fp,0,SEEK_END);
  4327. #ifdef HTS_FSEEKO
  4328.     i=ftello(fp);
  4329. #else
  4330.     i=ftell(fp);
  4331. #endif
  4332.     fclose(fp);
  4333.     return i;
  4334.   } else
  4335.     return -1;
  4336. }
  4337.  
  4338. off_t fpsize(FILE* fp) {
  4339.   off_t oldpos,size;
  4340.   if (!fp)
  4341.     return -1;
  4342. #ifdef HTS_FSEEKO
  4343.   oldpos=ftello(fp);
  4344. #else
  4345.   oldpos=ftell(fp);
  4346. #endif
  4347.   fseek(fp,0,SEEK_END);
  4348. #ifdef HTS_FSEEKO
  4349.   size=ftello(fp);
  4350.   fseeko(fp,oldpos,SEEK_SET);
  4351. #else
  4352.   size=ftell(fp);
  4353.   fseek(fp,oldpos,SEEK_SET);
  4354. #endif
  4355.   return size;
  4356. }
  4357.  
  4358. /* root dir, with ending / */
  4359. typedef struct {
  4360.   char path[1024+4];
  4361.   int init;
  4362. } hts_rootdir_strc;
  4363. HTSEXT_API char* hts_rootdir(char* file) {
  4364.   static hts_rootdir_strc strc = {"", 0};
  4365.   if (file) {
  4366.     if (!strc.init) {
  4367.       strc.path[0]='\0';
  4368.       strc.init=1;
  4369.       if (strnotempty(file)) {
  4370.         char* a;
  4371.         strcpybuff(strc.path,file);
  4372.         while((a=strrchr(strc.path,'\\'))) *a='/';
  4373.         if ((a=strrchr(strc.path,'/'))) {
  4374.           *(a+1)='\0';
  4375.         } else
  4376.           strc.path[0]='\0';
  4377.       }
  4378.       if (!strnotempty(strc.path)) {
  4379.         if( getcwd( strc.path, 1024 ) == NULL )
  4380.             strc.path[0]='\0';
  4381.         else
  4382.           strcatbuff(strc.path,"/");
  4383.       }
  4384.     }
  4385.     return NULL;
  4386.   } else if (strc.init)
  4387.     return strc.path;
  4388.   else
  4389.     return "";
  4390. }
  4391.  
  4392.  
  4393.  
  4394. HTSEXT_API hts_stat_struct HTS_STAT;
  4395. //
  4396. // return  number of downloadable bytes, depending on rate limiter
  4397. // see engine_stats() routine, too
  4398. // this routine works quite well for big files and regular ones, but apparently the rate limiter has
  4399. // some problems with very small files (rate too high)
  4400. LLint check_downloadable_bytes(int rate) {
  4401.   if (rate>0) {
  4402.     TStamp time_now;
  4403.     TStamp elapsed_useconds;
  4404.     LLint bytes_transfered_during_period;
  4405.     LLint left;
  4406.  
  4407.     // get the older timer
  4408.     int id_timer = (HTS_STAT.istat_idlasttimer + 1) % 2;
  4409.  
  4410.     time_now=mtime_local();
  4411.     elapsed_useconds = time_now - HTS_STAT.istat_timestart[id_timer];
  4412.     // NO totally stupid - elapsed_useconds+=1000;      // for the next second, too
  4413.     bytes_transfered_during_period = (HTS_STAT.HTS_TOTAL_RECV-HTS_STAT.istat_bytes[id_timer]);
  4414.     
  4415.     left = ((rate * elapsed_useconds)/1000) - bytes_transfered_during_period;
  4416.     if (left <= 0)
  4417.       left = 0;
  4418.     
  4419.     return left;
  4420.   } else
  4421.     return TAILLE_BUFFER;
  4422. }
  4423.  
  4424. //
  4425. // 0 : OK
  4426. // 1 : slow down
  4427. #if 0
  4428. int HTS_TOTAL_RECV_CHECK(int var) {
  4429.   if (HTS_STAT.HTS_TOTAL_RECV_STATE)
  4430.     return 1;
  4431.     /*
  4432.     {
  4433.     if (HTS_STAT.HTS_TOTAL_RECV_STATE==3) { 
  4434.       var = min(var,32); 
  4435.       Sleep(250); 
  4436.     } else if (HTS_STAT.HTS_TOTAL_RECV_STATE==2) { 
  4437.       var = min(var,256); 
  4438.       Sleep(100); 
  4439.     } else { 
  4440.       var/=2; 
  4441.       if (var<=0) var=1; 
  4442.       Sleep(50); 
  4443.     } 
  4444.   }
  4445.     */
  4446.   return 0;
  4447. }
  4448. #endif
  4449.  
  4450. // Lecture dans buff de size octets au maximum en utilisant la socket r (structure htsblk)
  4451. // returns: 
  4452. // >0 : data received
  4453. // == 0 : not yet data
  4454. // <0: error or no data: READ_ERROR, READ_EOF or READ_TIMEOUT
  4455. HTS_INLINE int hts_read(htsblk* r,char* buff,int size) {
  4456.   int retour;
  4457.   //  return read(soc,buff,size);
  4458.   if (r->is_file) {
  4459. #if HTS_WIDE_DEBUG    
  4460.     DEBUG_W("read(%p, %d, %d)\n" _ (void*) buff _ (int) size _ (int) r->fp);
  4461. #endif
  4462.     if (r->fp)
  4463.       retour = (int)fread(buff,1,size,r->fp);
  4464.     else
  4465.       retour = READ_ERROR;
  4466.   } else {
  4467. #if HTS_WIDE_DEBUG    
  4468.     DEBUG_W("recv(%d, %p, %d)\n" _ (int) r->soc _ (void*) buff _ (int) size);
  4469.     if (r->soc==INVALID_SOCKET)
  4470.       printf("!!WIDE_DEBUG ERROR, soc==INVALID hts_read\n");
  4471. #endif
  4472.     //HTS_TOTAL_RECV_CHECK(size);         // Diminuer au besoin si trop de donnΘes reτues
  4473. #if HTS_USEOPENSSL
  4474.     if (SSL_is_available && r->ssl) {
  4475.       retour = SSL_read(r->ssl_con, buff, size);
  4476.       if (retour <= 0) {
  4477.         int err_code = SSL_get_error(r->ssl_con, retour);
  4478.         if (
  4479.           (err_code == SSL_ERROR_WANT_READ)
  4480.           ||
  4481.           (err_code == SSL_ERROR_WANT_WRITE)
  4482.           ) 
  4483.         {
  4484.           retour = 0;             /* no data yet (ssl cache) */
  4485.         } else if (err_code == SSL_ERROR_ZERO_RETURN) {
  4486.           retour = READ_EOF;             /* completed */
  4487.         } else {
  4488.           retour = READ_ERROR;            /* eof or error */
  4489.         }
  4490.       }
  4491.     } else {
  4492. #endif
  4493.     retour=recv(r->soc,buff,size,0);
  4494.     if (retour == 0) {
  4495.       retour = READ_EOF;
  4496.     } else if (retour < 0) {
  4497.       retour = READ_ERROR;
  4498.     }
  4499.   }
  4500.   if (retour > 0)    // compter flux entrant
  4501.     HTS_STAT.HTS_TOTAL_RECV+=retour;
  4502. #if HTS_USEOPENSSL
  4503.   }
  4504. #endif
  4505. #if HTS_WIDE_DEBUG    
  4506.   DEBUG_W("recv/read done (%d bytes)\n" _ (int) retour);
  4507. #endif
  4508.   return retour;
  4509. }
  4510.  
  4511.  
  4512. // -- Gestion cache DNS --
  4513. // 'RX98
  4514. #if HTS_DNSCACHE
  4515.  
  4516. // 'capsule' contenant uniquement le cache
  4517. t_dnscache* _hts_cache(httrackp *opt) {
  4518.     if (opt->state.dns_cache == NULL) {
  4519.         opt->state.dns_cache = (t_dnscache*)malloct(sizeof(t_dnscache));
  4520.         memset(opt->state.dns_cache, 0, sizeof(t_dnscache));
  4521.     }
  4522.   return opt->state.dns_cache;
  4523. }
  4524. // free the cache
  4525. static void hts_cache_free_(t_dnscache* cache) {
  4526.   if (cache != NULL) {
  4527.     if (cache->n != NULL) {
  4528.       hts_cache_free_(cache->n);
  4529.     }
  4530.     freet(cache);
  4531.   }
  4532. }
  4533. void hts_cache_free(t_dnscache* cache) {
  4534.     if (cache != NULL && cache->n != NULL) {
  4535.         hts_cache_free_(cache->n);
  4536.         cache->n = NULL;
  4537.     }
  4538. }
  4539.  
  4540. // lock le cache dns pour tout opΘration d'ajout
  4541. // plus prudent quand plusieurs threads peuvent Θcrire dedans..
  4542. // -1: status? 0: libΘrer 1:locker
  4543.  
  4544. /* 
  4545.   Simple lock for cache
  4546. */
  4547. htsmutex dns_lock = HTSMUTEX_INIT;
  4548.  
  4549. // routine pour le cache - retour optionnel α donner α chaque fois
  4550. // NULL: nom non encore testΘ dans le cache
  4551. // si h_length==0 alors le nom n'existe pas dans le dns
  4552. t_hostent* _hts_ghbn(t_dnscache* cache,const char* iadr,t_hostent* retour) {
  4553.   t_hostent* ret = NULL;
  4554.   hts_mutexlock(&dns_lock);
  4555.   for(;;) {
  4556.     if (strcmp(cache->iadr,iadr) == 0) {  // ok trouvΘ
  4557.       if (cache->host_length > 0) {  // entrΘe valide
  4558.         if (retour->h_addr_list[0])
  4559.           memcpy(retour->h_addr_list[0], cache->host_addr, cache->host_length);
  4560.         retour->h_length=cache->host_length;
  4561.       } else if (cache->host_length == 0) {  // en cours
  4562.         ret = NULL;
  4563.         break;
  4564.       } else {                    // erreur dans le dns, dΘja vΘrifiΘ
  4565.         if (retour->h_addr_list[0])
  4566.           retour->h_addr_list[0][0]='\0';
  4567.         retour->h_length=0;  // erreur, n'existe pas
  4568.       }
  4569.       ret = retour;
  4570.       break;
  4571.     } else {    // on a pas encore trouvΘ
  4572.       if (cache->n!=NULL) { // chercher encore
  4573.         cache = cache->n;   // suivant!
  4574.       } else {
  4575.         ret = NULL;
  4576.         break;
  4577.       }
  4578.     }    
  4579.   }
  4580.   hts_mutexrelease(&dns_lock);
  4581.   return ret;
  4582. }
  4583.  
  4584. // tester si iadr a dΘja ΘtΘ testΘ (ou en cours de test)
  4585. // 0 non encore
  4586. // 1 ok
  4587. // 2 non prΘsent
  4588. int hts_dnstest(httrackp *opt, const char* _iadr) {
  4589.   int ret = 0;
  4590.   t_dnscache* cache=_hts_cache(opt);  // adresse du cache 
  4591.     char iadr[HTS_URLMAXSIZE*2];
  4592.  
  4593.   // sauter user:pass@ Θventuel
  4594.   strcpybuff(iadr, jump_identification(_iadr));
  4595.   // couper Θventuel :
  4596.   {
  4597.     char *a;
  4598.     if ( (a = jump_toport(iadr)) )
  4599.       *a='\0';
  4600.   }
  4601.  
  4602. #ifdef _WIN32
  4603.   if (inet_addr(iadr)!=INADDR_NONE)  // numΘrique
  4604. #else
  4605.   if (inet_addr(iadr)!=(in_addr_t) -1 )  // numΘrique
  4606. #endif
  4607.     return 1;
  4608.  
  4609.   hts_mutexlock(&dns_lock);
  4610.   for(;;) {
  4611.     if (strcmp(cache->iadr, iadr)==0) {  // ok trouvΘ
  4612.       ret = 1;
  4613.       break;
  4614.     } else {    // on a pas encore trouvΘ
  4615.       if (cache->n!=NULL) { // chercher encore
  4616.         cache=cache->n;   // suivant!
  4617.       } else {
  4618.         ret = 2;    // non prΘsent        
  4619.         break ;
  4620.       }
  4621.     }    
  4622.   }
  4623.   hts_mutexrelease(&dns_lock);
  4624.   return ret;
  4625. }
  4626.  
  4627.  
  4628. HTSEXT_API t_hostent* vxgethostbyname(char* hostname, void* v_buffer) {
  4629.   t_fullhostent* buffer = (t_fullhostent*) v_buffer;
  4630.   /* Clear */
  4631.   fullhostent_init(buffer);
  4632.  
  4633.   /* Protection */
  4634.   if (!strnotempty(hostname)) {
  4635.     return NULL;
  4636.   }
  4637.  
  4638.   /* 
  4639.     Strip [] if any : [3ffe:b80:1234:1::1] 
  4640.     The resolver doesn't seem to handle IP6 addresses in brackets
  4641.   */
  4642.   if ((hostname[0] == '[') && (hostname[strlen(hostname)-1] == ']')) {
  4643.     char BIGSTK tempo[HTS_URLMAXSIZE*2];
  4644.     tempo[0]='\0';
  4645.     strncatbuff(tempo, hostname+1, strlen(hostname)-2);
  4646.     strcpybuff(hostname, tempo);
  4647.   }
  4648.  
  4649.   {
  4650. #if HTS_INET6==0
  4651.   /*
  4652.   ipV4 resolver
  4653.     */
  4654.     t_hostent* hp=gethostbyname(hostname);
  4655.     if (hp!=NULL) {
  4656.       if ( (hp->h_length) && ( ((unsigned int) hp->h_length) <= buffer->addr_maxlen) ) {
  4657.         memcpy(buffer->hp.h_addr_list[0], hp->h_addr_list[0], hp->h_length);
  4658.         buffer->hp.h_length = hp->h_length;
  4659.         return &(buffer->hp);
  4660.       }
  4661.     }
  4662. #else
  4663.     /*
  4664.     ipV6 resolver
  4665.     */
  4666.     /*
  4667.     int error_num=0;
  4668.     t_hostent* hp=getipnodebyname(hostname, AF_INET6, AI_DEFAULT, &error_num);
  4669.     oops, deprecated :(
  4670.     */
  4671.     struct addrinfo* res = NULL;
  4672.     struct addrinfo hints;
  4673.     memset(&hints, 0, sizeof(hints));
  4674.     if (IPV6_resolver == 1)        // V4 only (for bogus V6 entries)
  4675.       hints.ai_family = PF_INET;
  4676.     else if (IPV6_resolver == 2)   // V6 only (for testing V6 only)
  4677.       hints.ai_family = PF_INET6;
  4678.     else                           // V4 + V6
  4679.       hints.ai_family = PF_UNSPEC;
  4680.     hints.ai_socktype = SOCK_STREAM;
  4681.     hints.ai_protocol = IPPROTO_TCP;
  4682.     if (getaddrinfo(hostname, NULL, &hints, &res) == 0) {
  4683.       if (res) {
  4684.         if ( (res->ai_addr) && (res->ai_addrlen) && (res->ai_addrlen <= buffer->addr_maxlen) ) {
  4685.           memcpy(buffer->hp.h_addr_list[0], res->ai_addr, res->ai_addrlen);
  4686.           buffer->hp.h_length = (short) res->ai_addrlen;
  4687.           freeaddrinfo(res);
  4688.           return &(buffer->hp);
  4689.         }
  4690.       }
  4691.     }
  4692.     if (res) {
  4693.       freeaddrinfo(res);
  4694.     }
  4695.     
  4696. #endif
  4697.   }
  4698.   return NULL;
  4699. }
  4700.  
  4701. // cache dns interne α HTS // ** FREE A FAIRE sur la chaine
  4702. t_hostent* hts_gethostbyname(httrackp *opt,const char* _iadr, void* v_buffer) {
  4703.   char BIGSTK iadr[HTS_URLMAXSIZE*2];
  4704.   t_fullhostent* buffer = (t_fullhostent*) v_buffer;
  4705.   t_dnscache* cache=_hts_cache(opt);  // adresse du cache
  4706.   t_hostent* hp;
  4707.  
  4708.   /* Clear */
  4709.   fullhostent_init(buffer);
  4710.  
  4711.   strcpybuff(iadr,jump_identification(_iadr));
  4712.   // couper Θventuel :
  4713.   {
  4714.     char *a;
  4715.     if ( (a=jump_toport(iadr)) )
  4716.       *a='\0';
  4717.   }
  4718.  
  4719.   // effacer structure de retour, crΘer nouvelle
  4720.   /*
  4721.   memset(&host, 0, sizeof(t_hostent));  
  4722.   host.h_addr_list=he;
  4723.   he[0]=NULL;
  4724.   he[1]=NULL;  
  4725.   host.h_length=0;  
  4726.   */
  4727.   cache->iadr[0]='*';
  4728.   cache->iadr[1]='\0';
  4729.   
  4730.   /* get IP from the dns cache */
  4731.   hp = _hts_ghbn(cache, iadr, &buffer->hp);
  4732.   if (hp) {
  4733.     if (hp->h_length>0)
  4734.       return hp;
  4735.     else
  4736.       return NULL;    // entrΘe erronΘe (erreur DNS) dans le DNS
  4737.   } else {  // non prΘsent dans le cache dns, tester
  4738.     t_dnscache* c=cache;
  4739.     while(c->n) c=c->n;    // calculer queue
  4740.     
  4741. #if HTS_WIDE_DEBUG    
  4742.     DEBUG_W("gethostbyname\n");
  4743. #endif      
  4744. #if HDEBUG
  4745.     printf("gethostbyname (not in cache)\n");
  4746. #endif
  4747.     {
  4748.       unsigned long inetaddr;
  4749. #ifdef _WIN32
  4750.       if ((inetaddr=inet_addr(iadr))==INADDR_NONE) {
  4751. #else
  4752.       if ((inetaddr=inet_addr(iadr))==(in_addr_t) -1 ) {
  4753. #endif        
  4754. #if DEBUGDNS 
  4755.         printf("resolving (not cached) %s\n",iadr);
  4756. #endif
  4757.         hp=vxgethostbyname(iadr, buffer);  // calculer IP host
  4758.       } else {     // numΘrique, convertir sans passer par le dns
  4759.         buffer->hp.h_addr_list[0]=(char*) &inetaddr;
  4760.         buffer->hp.h_length=4;
  4761.         hp=&buffer->hp;
  4762.       }
  4763.     }
  4764. #if HTS_WIDE_DEBUG    
  4765.     DEBUG_W("gethostbyname done\n");
  4766. #endif
  4767.     cache->n=(t_dnscache*) calloct(1,sizeof(t_dnscache));
  4768.     if (cache->n!=NULL) {
  4769.       strcpybuff(cache->n->iadr,iadr);
  4770.       if (hp!=NULL) {
  4771.         memcpy(cache->n->host_addr, hp->h_addr_list[0], hp->h_length);
  4772.         cache->n->host_length=hp->h_length;
  4773.       } else {
  4774.         cache->n->host_addr[0]='\0';
  4775.         cache->n->host_length=0;  // non existant dans le dns
  4776.       }
  4777.       cache->n->n=NULL;
  4778.       return hp;
  4779.     } else {  // on peut pas noter, mais on peut renvoyer le rΘsultat
  4780.       return hp;
  4781.     }        
  4782.   }  // retour hp du cache
  4783. }
  4784.  
  4785. #else
  4786. HTS_INLINE t_hostent* hts_gethostbyname(httrackp *opt,char* iadr, t_fullhostent* buffer) {
  4787.   t_hostent* retour;
  4788. #if HTS_WIDE_DEBUG    
  4789.   DEBUG_W("gethostbyname (2)\n");
  4790. #endif
  4791. #if DEBUGDNS 
  4792.     printf("blocking method gethostbyname() in progress for %s\n",iadr);
  4793. #endif
  4794.   retour=vxgethostbyname(jump_identification(iadr), );
  4795. #if HTS_WIDE_DEBUG    
  4796.   DEBUG_W("gethostbyname (2) done\n");
  4797. #endif
  4798.   return retour;
  4799. }
  4800. #endif
  4801.  
  4802.  
  4803. // --- Tracage des mallocs() ---
  4804. #ifdef HTS_TRACE_MALLOC
  4805. //#define htsLocker(A, N) htsLocker(A, N)
  4806. #define htsLocker(A, N) do {} while(0)
  4807. static mlink trmalloc = {NULL,0,0,NULL};
  4808. static int trmalloc_id=0;
  4809. static htsmutex* mallocMutex = NULL;
  4810. static void hts_meminit(void) {
  4811.   //if (mallocMutex == NULL) {
  4812.   //  mallocMutex = calloc(sizeof(*mallocMutex), 1);
  4813.   //  htsLocker(mallocMutex, -999);
  4814.   //}
  4815. }
  4816. void* hts_malloc(size_t len) {
  4817.   void* adr;
  4818.   hts_meminit();
  4819.   htsLocker(mallocMutex, 1);
  4820.   fassert(len > 0);
  4821.   adr = hts_xmalloc(len, 0);
  4822.   htsLocker(mallocMutex, 0);
  4823.   return adr;
  4824. }
  4825. void* hts_calloc(size_t len,size_t len2) {
  4826.   void* adr;
  4827.   hts_meminit();
  4828.   fassert(len > 0);
  4829.   fassert(len2 > 0);
  4830.   htsLocker(mallocMutex, 1);
  4831.   adr = hts_xmalloc(len, len2);
  4832.   htsLocker(mallocMutex, 0);
  4833.   memset(adr, 0, len * len2);
  4834.   return adr;
  4835. }
  4836. void* hts_strdup(char* str) {
  4837.   size_t size = str ? strlen(str) : 0;
  4838.   char* adr = (char*) hts_malloc(size + 1);
  4839.   fassert(adr != NULL);
  4840.   strcpy(adr, str ? str : "");
  4841.   return adr;
  4842. }
  4843. void* hts_xmalloc(size_t len,size_t len2) {
  4844.   mlink* lnk = (mlink*) calloc(1,sizeof(mlink));
  4845.   fassert(lnk != NULL);
  4846.   fassert(len > 0);
  4847.   fassert(len2 >= 0);
  4848.   if (lnk) {
  4849.     void*  r   = NULL;
  4850.     int size, bsize = sizeof(t_htsboundary);
  4851.     if (len2)
  4852.       size = len * len2;
  4853.     else
  4854.       size = len;
  4855.     size += ((bsize - (size % bsize)) % bsize);  /* check alignement */
  4856.     r = malloc(size + bsize*2);
  4857.     fassert(r != NULL);
  4858.     if (r) {
  4859.       * ( (t_htsboundary*) ((char*) r ) ) 
  4860.         = * ( (t_htsboundary*) ( (char*) r + size + bsize ) )
  4861.         = htsboundary;
  4862.       ((char*) r) += bsize;    /* boundary */
  4863.       lnk->adr = r;
  4864.       lnk->len = size;
  4865.       lnk->id = trmalloc_id++;
  4866.       lnk->next = trmalloc.next;
  4867.       trmalloc.next = lnk;
  4868.       return r;
  4869.     } else {
  4870.       free(lnk);
  4871.     }
  4872.   }
  4873.   return NULL;
  4874. }
  4875. void hts_free(void* adr) {
  4876.   mlink* lnk = &trmalloc;
  4877.   int bsize = sizeof(t_htsboundary);
  4878.   fassert(adr != NULL);
  4879.   if (!adr) {
  4880.     return;
  4881.   }
  4882.   htsLocker(mallocMutex, 1);
  4883.   while(lnk->next != NULL) {
  4884.     if (lnk->next->adr == adr) {
  4885.       mlink* blk_free=lnk->next;
  4886.       fassert(blk_free->id != -1);
  4887.       fassert( * ( (t_htsboundary*) ( (char*) adr - bsize ) ) == htsboundary );
  4888.       fassert( * ( (t_htsboundary*) ( (char*) adr + blk_free->len ) ) == htsboundary );
  4889.       lnk->next=lnk->next->next;
  4890.       free((void*) blk_free);
  4891.       //blk_free->id=-1;
  4892.       free((char*) adr - bsize);
  4893.       htsLocker(mallocMutex, 0);
  4894.       return;
  4895.     }
  4896.     lnk = lnk->next;
  4897.     fassert(lnk->next != NULL);
  4898.   }
  4899.   free(adr);
  4900.   htsLocker(mallocMutex, 0);
  4901. }
  4902. void* hts_realloc(void* adr,size_t len) {
  4903.   int bsize = sizeof(t_htsboundary);
  4904.   len += ((bsize - (len % bsize)) % bsize);  /* check alignement */
  4905.   if (adr != NULL) {
  4906.     mlink* lnk = &trmalloc;
  4907.     htsLocker(mallocMutex, 1);
  4908.     while(lnk->next != NULL)  {
  4909.       if (lnk->next->adr==adr) {
  4910.         {
  4911.           mlink* blk_free=lnk->next;
  4912.           fassert(blk_free->id != -1);
  4913.           fassert( * ( (t_htsboundary*) ( (char*) adr - bsize ) ) == htsboundary );
  4914.           fassert( * ( (t_htsboundary*) ( (char*) adr + blk_free->len ) ) == htsboundary );
  4915.         }
  4916.         adr = realloc((char*) adr - bsize, len + bsize * 2);
  4917.         fassert(adr != NULL);
  4918.         lnk->next->adr = (char*) adr + bsize;
  4919.         lnk->next->len = len;
  4920.         * ( (t_htsboundary*) ( (char*) adr ) ) 
  4921.           = * ( (t_htsboundary*) ( (char*) adr + len + bsize) ) 
  4922.           = htsboundary;
  4923.         htsLocker(mallocMutex, 0);
  4924.         return (char*) adr + bsize;
  4925.       }
  4926.       lnk = lnk->next;
  4927.       fassert(lnk->next != NULL);
  4928.     }
  4929.     htsLocker(mallocMutex, 0);
  4930.   }
  4931.   return hts_malloc(len);
  4932. }
  4933. mlink* hts_find(char* adr) {
  4934.   char* stkframe = (char*) &stkframe;
  4935.   mlink* lnk = &trmalloc;
  4936.   int bsize = sizeof(t_htsboundary);
  4937.   fassert(adr != NULL);
  4938.   if (!adr) {
  4939.     return NULL;
  4940.   }
  4941.   htsLocker(mallocMutex, 1);
  4942.   while(lnk->next != NULL) {
  4943.     if (adr >= lnk->next->adr && adr <= lnk->next->adr + lnk->next->len) {   /* found */
  4944.       htsLocker(mallocMutex, 0);
  4945.       return lnk->next;
  4946.     }
  4947.     lnk = lnk->next;
  4948.   }
  4949.   htsLocker(mallocMutex, 0);
  4950.   {
  4951.     int depl = (int) (adr - stkframe);
  4952.     if (depl < 0) depl = -depl;
  4953.     //fassert(depl < 512000);   /* near the stack frame.. doesn't look like malloc but stack variable */
  4954.     return NULL;
  4955.   }
  4956. }
  4957. // check the malloct() and calloct() trace stack
  4958. void  hts_freeall(void) {
  4959.   int bsize = sizeof(t_htsboundary);
  4960.   while(trmalloc.next) {
  4961. #if MEMDEBUG
  4962.     printf("* block %d\t not released: at %d\t (%d\t bytes)\n",trmalloc.next->id,trmalloc.next->adr,trmalloc.next->len);
  4963. #endif
  4964.     if (trmalloc.next->id != -1) {
  4965.       free((char*) trmalloc.next->adr - bsize);
  4966.     }
  4967.   }
  4968. }
  4969. #endif
  4970.  
  4971.  
  4972. // -- divers //
  4973.  
  4974. // cut path and project name
  4975. // patch also initial path
  4976. void cut_path(char* fullpath,char* path,char* pname) {
  4977.   path[0]=pname[0]='\0';
  4978.   if (strnotempty(fullpath)) {
  4979.     if ((fullpath[strlen(fullpath)-1]=='/') || (fullpath[strlen(fullpath)-1]=='\\'))
  4980.       fullpath[strlen(fullpath)-1]='\0';
  4981.     if (strlen(fullpath)>1) {
  4982.       char* a;
  4983.       while( (a=strchr(fullpath,'\\')) ) *a='/';     // remplacer par /
  4984.       a=fullpath+strlen(fullpath)-2;
  4985.       while( (*a!='/') && ( a > fullpath)) a--;
  4986.       if (*a=='/') a++;
  4987.       strcpybuff(pname,a);
  4988.       strncatbuff(path,fullpath,(int) (a - fullpath));
  4989.     }
  4990.   }
  4991. }
  4992.  
  4993.  
  4994.  
  4995. // -- Gestion protocole ftp --
  4996.  
  4997. #ifdef _WIN32
  4998. int ftp_available(void) {
  4999.   return 1;
  5000. }
  5001. #else
  5002. int ftp_available(void) {
  5003.   return 1;   // ok!
  5004.   //return 0;   // SOUS UNIX, PROBLEMESs
  5005. }
  5006. #endif
  5007.  
  5008.  
  5009. int hts_dgb_init = 0;
  5010. FILE* hts_dgb_init_fp = NULL;
  5011. HTSEXT_API void hts_debug(int level) {
  5012.   hts_dgb_init = level;
  5013.   if (hts_dgb_init > 0) {
  5014.     HTS_DBG("hts_debug() called");
  5015.   }
  5016. }
  5017.  
  5018. FILE *hts_dgb_(void) {
  5019.   if (hts_dgb_init_fp == NULL) {
  5020.     if ((hts_dgb_init & 0x80) == 0) {
  5021.       hts_dgb_init_fp = stderr;
  5022.     } else {
  5023. #ifdef _WIN32_WCE
  5024.       hts_dgb_init_fp = fopen("\\Temp\\hts-debug.txt", "wb");
  5025. #else
  5026.       hts_dgb_init_fp = fopen("hts-debug.txt", "wb");
  5027. #endif
  5028.       if (hts_dgb_init_fp != NULL) {
  5029.         fprintf(hts_dgb_init_fp, "* Creating file\r\n");
  5030.       }
  5031.     }
  5032.   }
  5033.   return hts_dgb_init_fp;
  5034. }
  5035.  
  5036. static int hts_init_ok = 0;
  5037. HTSEXT_API int hts_init(void) {
  5038.   const char *dbg_env;
  5039.   /* */
  5040.   if (hts_init_ok)
  5041.     return 1;
  5042.   hts_init_ok = 1;
  5043.  
  5044.   /* enable debugging ? */
  5045.   dbg_env = getenv("HTS_LOG");
  5046.   if (dbg_env != NULL && *dbg_env != 0) {
  5047.     int level = 0;
  5048.     if (sscanf(dbg_env, "%d", &level) == 1) {
  5049.       hts_debug(level);
  5050.     }
  5051.   }
  5052.  
  5053.   HTS_DBG("entering hts_init()");    /* debug */
  5054.  
  5055. #ifdef _WIN32_WCE
  5056. #ifndef HTS_CECOMPAT
  5057.   xceinit(L"");
  5058. #endif
  5059. #endif
  5060.  
  5061.   /* Init threads (lazy init) */
  5062.   htsthread_init();
  5063.  
  5064.   /* Ensure external modules are loaded */
  5065.   HTS_DBG("calling htspe_init()");    /* debug */
  5066.   htspe_init();  /* module load (lazy) */
  5067.  
  5068.   /* MD5 Auto-test */
  5069.   {
  5070.     char digest[32 + 2];
  5071.     const unsigned char* atest = (const unsigned char*)"MD5 Checksum Autotest";
  5072.     digest[0] = '\0';
  5073.     domd5mem(atest, strlen(atest), digest, 1); /* a42ec44369da07ace5ec1d660ba4a69a */
  5074.     if (strcmp(digest, "a42ec44369da07ace5ec1d660ba4a69a") != 0) {
  5075.       int fatal_broken_md5 = 0;
  5076.       assertf(fatal_broken_md5);
  5077.     }
  5078.   }
  5079.  
  5080.   HTS_DBG("initializing SSL");    /* debug */
  5081. #if HTS_USEOPENSSL
  5082.   /*
  5083.   Initialize the OpensSSL library
  5084.   */
  5085.   if (!openssl_ctx && SSL_is_available) {
  5086.     if (SSL_load_error_strings) SSL_load_error_strings();
  5087.     SSL_library_init();
  5088.     ///if (SSL_load_error_strings)  SSL_load_error_strings();
  5089.     //if (ERR_load_crypto_strings) ERR_load_crypto_strings();
  5090.     // if (ERR_load_SSL_strings)    ERR_load_SSL_strings(); ???!!!
  5091.     // OpenSSL_add_all_algorithms();
  5092.     openssl_ctx = SSL_CTX_new(SSLv23_client_method());
  5093.     if (!openssl_ctx) {
  5094.       fprintf(stderr, "fatal: unable to initialize TLS: SSL_CTX_new(SSLv23_client_method)\n");
  5095.       abortLog("unable to initialize TLS: SSL_CTX_new(SSLv23_client_method)");
  5096.       assertf("unable to initialize TLS" == NULL);
  5097.     }
  5098.   }
  5099. #endif
  5100.   
  5101.   HTS_DBG("ending hts_init()");    /* debug */
  5102.   return 1;
  5103. }
  5104.  
  5105. /* will not free thread env. */
  5106. HTSEXT_API int hts_uninit(void) {
  5107.   /* hts_init() is a lazy initializer, with limited a allocation (one or two mutexes) ;
  5108.   we won't free anything here as the .h semantic was never being very clear */
  5109.   return 1;
  5110. }
  5111.  
  5112. HTSEXT_API int hts_uninit_module(void) {
  5113.   if (!hts_init_ok)
  5114.     return 1;
  5115.   htsthread_uninit();
  5116.   htspe_uninit();
  5117.   hts_init_ok = 0;
  5118.   return 1;
  5119. }
  5120.  
  5121. HTSEXT_API int hts_log(httrackp *opt, const char* prefix, const char *msg) {
  5122.   if (opt->log != NULL) {
  5123.     fspc(opt, opt->log, prefix);
  5124.     fprintf(opt->log, "%s"LF, msg);
  5125.     return 0;
  5126.   }
  5127.   return 1;   /* Error */
  5128. }
  5129.  
  5130. HTSEXT_API void set_wrappers(httrackp *opt) {        // LEGACY
  5131. }
  5132.  
  5133. HTSEXT_API int plug_wrapper(httrackp *opt, const char *moduleName, const char* argv) {
  5134.   void* handle = openFunctionLib(moduleName);
  5135.   if (handle != NULL) {
  5136.     t_hts_plug plug = (t_hts_plug) getFunctionPtr(handle, "hts_plug");
  5137.     t_hts_unplug unplug = (t_hts_unplug) getFunctionPtr(handle, "hts_unplug");
  5138.     if (plug != NULL) {
  5139.       int ret = plug(opt, argv);
  5140.       if (hts_dgb_init > 0 && opt->log != NULL) {
  5141.         HTS_DBG("plugged module '%s' (return code=%d)" _ moduleName _ ret);
  5142.       }
  5143.       if (ret == 1) {   /* Success! */
  5144.         opt->libHandles.handles = (htslibhandle*) realloct(opt->libHandles.handles, ( opt->libHandles.count + 1 )*sizeof(htslibhandle));
  5145.         opt->libHandles.handles[opt->libHandles.count].handle = handle;
  5146.         opt->libHandles.handles[opt->libHandles.count].moduleName = strdupt(moduleName);
  5147.         opt->libHandles.count++;
  5148.         return 1;
  5149.       } else {
  5150.         HTS_DBG("* note: error while running entry point 'hts_plug' in %s"LF _ moduleName);
  5151.         if (unplug)
  5152.           unplug(opt);
  5153.       }
  5154.     } else {
  5155.       int last_errno = errno;
  5156.       HTS_DBG("* note: can't find entry point 'hts_plug' in %s: %s"LF _ moduleName _ strerror(last_errno));
  5157.     }
  5158.     closeFunctionLib(handle);
  5159.     return 0;
  5160.   } else {
  5161.     int last_errno = errno;
  5162.     HTS_DBG("* note: can't load %s: %s"LF _ moduleName _ strerror(last_errno));
  5163.   }
  5164.   return -1;
  5165. }
  5166.  
  5167. static void unplug_wrappers(httrackp *opt) {
  5168.   if (opt->libHandles.handles != NULL) {
  5169.     int i;
  5170.     for(i = 0 ; i < opt->libHandles.count ; i++) {
  5171.       if (opt->libHandles.handles[i].handle != NULL) {
  5172.         /* hts_unplug(), the dll exit point (finalizer) */
  5173.         t_hts_unplug unplug = (t_hts_unplug) getFunctionPtr(opt->libHandles.handles[i].handle, "hts_unplug");
  5174.         if (unplug != NULL)
  5175.           unplug(opt);
  5176.         closeFunctionLib(opt->libHandles.handles[i].handle);
  5177.         opt->libHandles.handles[i].handle = NULL;
  5178.       }
  5179.       if (opt->libHandles.handles[i].moduleName != NULL) {
  5180.         freet(opt->libHandles.handles[i].moduleName);
  5181.         opt->libHandles.handles[i].moduleName = NULL;
  5182.       }
  5183.     }
  5184.     freet(opt->libHandles.handles);
  5185.     opt->libHandles.handles = NULL;
  5186.     opt->libHandles.count = 0;
  5187.   }
  5188. }
  5189.  
  5190. int multipleStringMatch(const char *s, const char *match) {
  5191.   int ret = 0;
  5192.   String name = STRING_EMPTY;
  5193.   if (match  == NULL || s == NULL || *s == 0)
  5194.     return 0;
  5195.   for( ; *match != 0 ; match++) {
  5196.     StringClear(name);
  5197.     for( ; *match != 0 && *match != '\n' ; match++) {
  5198.       StringAddchar(name, *match);
  5199.     }
  5200.     if (StringLength(name) > 0 && strstr(s, StringBuff(name)) != NULL) {
  5201.       ret = 1;
  5202.       break ;
  5203.     }
  5204.   }
  5205.   StringFree(name);
  5206.   return ret;
  5207. }
  5208.  
  5209. HTSEXT_API httrackp *hts_create_opt(void) {
  5210. #ifdef _WIN32
  5211.   static const char *defaultModules[] = { 
  5212.     "htsswf", "htsjava", "httrack-plugin", NULL 
  5213.   };
  5214. #else
  5215.   static const char *defaultModules[] = { 
  5216.     "libhtsswf.so.1", "libhtsjava.so.2", "httrack-plugin", NULL 
  5217.   };
  5218. #endif
  5219.   httrackp *opt = malloc(sizeof(httrackp));
  5220.  
  5221.   /* default options */
  5222.   memset(opt, 0, sizeof(httrackp));
  5223.   opt->size_httrackp = sizeof(httrackp);
  5224.  
  5225.   /* mutexes */
  5226.   hts_mutexinit(&opt->state.lock);
  5227.  
  5228.     /* custom wrappers */
  5229.   opt->libHandles.count = 0;
  5230.  
  5231.     /* default settings */
  5232.  
  5233.     opt->wizard=2;   // wizard automatique
  5234.   opt->quiet=0;     // questions
  5235.   //  
  5236.   opt->travel=0;   // mΩme adresse
  5237.   opt->depth=9999; // mirror total par dΘfaut
  5238.   opt->extdepth=0; // mais pas α l'extΘrieur
  5239.   opt->seeker=1;   // down 
  5240.   opt->urlmode=2;  // relatif par dΘfaut
  5241.   opt->debug=0;    // pas de dΘbug en plus
  5242.   opt->getmode=3;  // linear scan
  5243.   opt->maxsite=-1; // taille max site (aucune)
  5244.   opt->maxfile_nonhtml=-1; // taille max fichier non html
  5245.   opt->maxfile_html=-1;    // idem pour html
  5246.   opt->maxsoc=4;     // nbre socket max
  5247.   opt->fragment=-1;  // pas de fragmentation
  5248.   opt->nearlink=0;   // ne pas prendre les liens non-html "adjacents"
  5249.   opt->makeindex=1;  // faire un index
  5250.   opt->kindex=0;     // index 'keyword'
  5251.   opt->delete_old=1; // effacer anciens fichiers
  5252.   opt->makestat=0;  // pas de fichier de stats
  5253.   opt->maketrack=0; // ni de tracking
  5254.   opt->timeout=120; // timeout par dΘfaut (2 minutes)
  5255.   opt->cache=1;     // cache prioritaire
  5256.   opt->shell=0;     // pas de shell par defaut
  5257.   opt->proxy.active=0;    // pas de proxy
  5258.   opt->user_agent_send=1; // envoyer un user-agent
  5259.   StringCopy(opt->user_agent, "Mozilla/4.5 (compatible; HTTrack 3.0x; Windows 98)");
  5260.   StringCopy(opt->referer, "");
  5261.   StringCopy(opt->from, "");
  5262.   opt->savename_83=0;     // noms longs par dΘfaut
  5263.   opt->savename_type=0;   // avec structure originale
  5264.   opt->savename_delayed=2;// hard delayed type (default)
  5265.   opt->delayed_cached=1;  // cached delayed type (default)
  5266.   opt->mimehtml=0;        // pas MIME-html
  5267.   opt->parsejava=HTSPARSE_DEFAULT; // parser classes
  5268.   opt->hostcontrol=0;     // PAS de control host pour timeout et traffic jammer
  5269.   opt->retry=2;           // 2 retry par dΘfaut
  5270.   opt->errpage=1;         // copier ou gΘnΘrer une page d'erreur en cas d'erreur (404 etc.)
  5271.   opt->check_type=1;      // vΘrifier type si inconnu (cgi,asp..) SAUF / considΘrΘ comme html
  5272.   opt->all_in_cache=0;    // ne pas tout stocker en cache
  5273.   opt->robots=2;          // traiter les robots.txt
  5274.   opt->external=0;        // liens externes normaux
  5275.   opt->passprivacy=0;     // mots de passe dans les fichiers
  5276.   opt->includequery=1;    // include query-string par dΘfaut
  5277.   opt->mirror_first_page=0;  // pas mode mirror links
  5278.   opt->accept_cookie=1;   // gΘrer les cookies
  5279.   opt->cookie=NULL;
  5280.   opt->http10=0;          // laisser http/1.1
  5281.   opt->nokeepalive = 0;   // pas keep-alive
  5282.   opt->nocompression=0;   // pas de compression
  5283.   opt->tolerant=0;        // ne pas accepter content-length incorrect
  5284.   opt->parseall=1;        // tout parser (tags inconnus, par exemple)
  5285.   opt->parsedebug=0;      // pas de mode dΘbuggage
  5286.   opt->norecatch=0;       // ne pas reprendre les fichiers effacΘs par l'utilisateur
  5287.   opt->verbosedisplay=0;  // pas d'animation texte
  5288.   opt->sizehack=0;        // size hack
  5289.   opt->urlhack=1;         // url hack (normalizer)
  5290.   StringCopy(opt->footer,HTS_DEFAULT_FOOTER);
  5291.   opt->ftp_proxy=1;       // proxy http pour ftp
  5292.   StringCopy(opt->filelist,"");
  5293.   StringCopy(opt->lang_iso,"en, *");
  5294.   StringCopy(opt->mimedefs,"\n"); // aucun filtre mime (\n IMPORTANT)
  5295.   StringClear(opt->mod_blacklist);
  5296.   //
  5297.   opt->log = stdout;
  5298.   opt->errlog = stderr;
  5299.   opt->flush = 1;         // flush sur les fichiers log
  5300.   //opt->aff_progress=0;
  5301.   opt->keyboard=0;
  5302.   //
  5303.   StringCopy(opt->path_html,"");
  5304.   StringCopy(opt->path_log,"");
  5305.   StringCopy(opt->path_bin,"");
  5306.   //
  5307. #if HTS_SPARE_MEMORY==0
  5308.   opt->maxlink=100000;    // 100,000 liens max par dΘfaut (400Kb)
  5309.   opt->maxfilter=200;     // 200 filtres max par dΘfaut
  5310. #else
  5311.   opt->maxlink=10000;     // 10,000 liens max par dΘfaut (40Kb)
  5312.   opt->maxfilter=50;      // 50 filtres max par dΘfaut
  5313. #endif
  5314.   opt->maxcache=1048576*32;  // a peu prΦs 32Mo en cache max -- OPTION NON PARAMETRABLE POUR L'INSTANT --
  5315.   //opt->maxcache_anticipate=256;  // maximum de liens α anticiper
  5316.   opt->maxtime=-1;        // temps max en secondes
  5317. #if HTS_USEMMS
  5318.     opt->mms_maxtime = 60*3600;        // max time for mms streams (one hour)
  5319. #endif
  5320.   opt->maxrate=25000;     // taux maxi
  5321.   opt->maxconn=5.0;       // nombre connexions/s
  5322.   opt->waittime=-1;       // wait until.. hh*3600+mm*60+ss
  5323.   //
  5324.   opt->exec="";
  5325.   opt->is_update=0;      // not an update (yet)
  5326.   opt->dir_topindex=0;   // do not built top index (yet)
  5327.   //
  5328.   opt->bypass_limits=0;  // enforce limits by default
  5329.   opt->state.stop=0;     // stopper
  5330.   opt->state.exit_xh=0;  // abort
  5331.  
  5332.   /* Alocated buffers */
  5333.  
  5334.     opt->callbacks_fun = (t_hts_htmlcheck_callbacks*) malloct(sizeof(t_hts_htmlcheck_callbacks));
  5335.     memset(opt->callbacks_fun, 0, sizeof(t_hts_htmlcheck_callbacks));
  5336.  
  5337.   /* Preload callbacks : java and flash parser, and the automatic user-defined callback */
  5338.  
  5339.   {
  5340.     int i;
  5341.     for(i = 0 ; defaultModules[i] != NULL ; i++) {
  5342.       int ret = plug_wrapper(opt, defaultModules[i], defaultModules[i]);
  5343.       if (ret == 0) {     /* Module aborted initialization */
  5344.         /* Ignored. */
  5345.       }
  5346.     }
  5347.   }
  5348.  
  5349.     return opt;
  5350. }
  5351.  
  5352. HTSEXT_API void hts_free_opt(httrackp *opt) {
  5353.   if (opt != NULL) {
  5354.  
  5355.     /* Alocated callbacks */
  5356.  
  5357.     if (opt->callbacks_fun != NULL) {
  5358.       int i;
  5359.       t_hts_htmlcheck_callbacks_item *items = (t_hts_htmlcheck_callbacks_item*) opt->callbacks_fun;
  5360.       const int size = (int) sizeof(t_hts_htmlcheck_callbacks) / sizeof(t_hts_htmlcheck_callbacks_item);
  5361.       assertf(sizeof(t_hts_htmlcheck_callbacks_item)*size == sizeof(t_hts_htmlcheck_callbacks));
  5362.  
  5363.       /* Free all linked lists */
  5364.       for(i = 0 ; i < size ; i++) {
  5365.         t_hts_callbackarg *carg, *next_carg;
  5366.         for(carg = items[i].carg ; carg != NULL && (next_carg = carg->prev.carg, carg != NULL) ; carg = next_carg ) {
  5367.           hts_free(carg);
  5368.         }
  5369.       }
  5370.  
  5371.       freet(opt->callbacks_fun);
  5372.       opt->callbacks_fun = NULL;
  5373.     }
  5374.  
  5375.     /* Close library handles */
  5376.     unplug_wrappers(opt);
  5377.  
  5378.     /* Cache */
  5379.     if (opt->state.dns_cache != NULL) {
  5380.       hts_cache_free(opt->state.dns_cache);
  5381.       opt->state.dns_cache = NULL;
  5382.     }
  5383.  
  5384.     /* Cancel chain */
  5385.     if (opt->state.cancel != NULL) {
  5386.       htsoptstatecancel *cancel;
  5387.       for(cancel = opt->state.cancel ; cancel != NULL ; ) {
  5388.         htsoptstatecancel *next = cancel->next;
  5389.         if (cancel->url != NULL) {
  5390.           freet(cancel->url);
  5391.         }
  5392.         freet(cancel);
  5393.         cancel = next;
  5394.       }
  5395.       opt->state.cancel = NULL;
  5396.     }
  5397.  
  5398.     /* Free strings */
  5399.  
  5400.     StringFree(opt->proxy.name);
  5401.     StringFree(opt->proxy.bindhost);
  5402.  
  5403.     StringFree(opt->savename_userdef);
  5404.     StringFree(opt->user_agent);
  5405.     StringFree(opt->referer);
  5406.     StringFree(opt->from);
  5407.     StringFree(opt->lang_iso);
  5408.     StringFree(opt->sys_com);
  5409.     StringFree(opt->mimedefs);
  5410.     StringFree(opt->filelist);
  5411.     StringFree(opt->urllist);
  5412.     StringFree(opt->footer);
  5413.     StringFree(opt->mod_blacklist);
  5414.  
  5415.     StringFree(opt->path_html);
  5416.     StringFree(opt->path_log);
  5417.     StringFree(opt->path_bin);
  5418.  
  5419.     /* mutexes */
  5420.     hts_mutexfree(&opt->state.lock);
  5421.  
  5422.     /* Free structure */
  5423.     free(opt);
  5424.   }
  5425. }
  5426.  
  5427. // defaut wrappers
  5428. static void __cdecl htsdefault_init(t_hts_callbackarg *carg) {
  5429. }
  5430. static void __cdecl htsdefault_uninit(t_hts_callbackarg *carg) {
  5431.   // hts_freevar();
  5432. }
  5433. static int __cdecl htsdefault_start(t_hts_callbackarg *carg, httrackp* opt) {
  5434.   return 1; 
  5435. }
  5436. static int __cdecl htsdefault_chopt(t_hts_callbackarg *carg, httrackp* opt) {
  5437.   return 1;
  5438. }
  5439. static int  __cdecl htsdefault_end(t_hts_callbackarg *carg, httrackp* opt) { 
  5440.   return 1; 
  5441. }
  5442. static int __cdecl htsdefault_preprocesshtml(t_hts_callbackarg *carg, httrackp *opt, char** html,int* len,const char* url_adresse,const char* url_fichier) {
  5443.   return 1;
  5444. }
  5445. static int __cdecl htsdefault_postprocesshtml(t_hts_callbackarg *carg, httrackp *opt, char** html,int* len,const char* url_adresse,const char* url_fichier) {
  5446.   return 1;
  5447. }
  5448. static int __cdecl htsdefault_checkhtml(t_hts_callbackarg *carg, httrackp *opt, char* html,int len,const char* url_adresse,const char* url_fichier) {
  5449.   return 1;
  5450. }
  5451. static int __cdecl htsdefault_loop(t_hts_callbackarg *carg, httrackp *opt, lien_back* back,int back_max,int back_index,int lien_n,int lien_tot,int stat_time,hts_stat_struct* stats) {    // appelΘ α chaque boucle de HTTrack
  5452.   return 1;
  5453. }
  5454. static const char* __cdecl htsdefault_query(t_hts_callbackarg *carg, httrackp *opt, const char* question) {
  5455.   return "";
  5456. }
  5457. static const char* __cdecl htsdefault_query2(t_hts_callbackarg *carg, httrackp *opt, const char* question) {
  5458.   return "";
  5459. }
  5460. static const char* __cdecl htsdefault_query3(t_hts_callbackarg *carg, httrackp *opt, const char* question) {
  5461.   return "";
  5462. }
  5463. static int __cdecl htsdefault_check(t_hts_callbackarg *carg, httrackp *opt, const char* adr,const char* fil,int status) {
  5464.   return -1;
  5465. }
  5466. static int __cdecl htsdefault_check_mime(t_hts_callbackarg *carg, httrackp *opt, const char* adr,const char* fil,const char* mime,int status) {
  5467.   return -1;
  5468. }
  5469. static void __cdecl htsdefault_pause(t_hts_callbackarg *carg, httrackp *opt, const char* lockfile) {
  5470.   while (fexist(lockfile)) {
  5471.     Sleep(1000);
  5472.   }
  5473. }
  5474. static void __cdecl htsdefault_filesave(t_hts_callbackarg *carg, httrackp *opt, const char* file) {
  5475. }
  5476. static void __cdecl htsdefault_filesave2(t_hts_callbackarg *carg, httrackp *opt, const char* adr, const char* file, const char* sav, int is_new, int is_modified, int not_updated) {
  5477. }
  5478. static int __cdecl htsdefault_linkdetected(t_hts_callbackarg *carg, httrackp *opt, char* link) {
  5479.   return 1;
  5480. }
  5481. static int __cdecl htsdefault_linkdetected2(t_hts_callbackarg *carg, httrackp *opt, char* link, const char* start_tag) {
  5482.   return 1;
  5483. }
  5484. static int __cdecl htsdefault_xfrstatus(t_hts_callbackarg *carg, httrackp *opt, lien_back* back) {
  5485.   return 1;
  5486. }
  5487. static int __cdecl htsdefault_savename(t_hts_callbackarg *carg, httrackp *opt, const char* adr_complete,const char* fil_complete,const char* referer_adr,const char* referer_fil,char* save) {
  5488.   return 1;
  5489. }
  5490. static int __cdecl htsdefault_sendhead(t_hts_callbackarg *carg, httrackp *opt, char* buff, const char* adr, const char* fil, const char* referer_adr, const char* referer_fil, htsblk* outgoing) {
  5491.   return 1;
  5492. }
  5493. static int __cdecl htsdefault_receivehead(t_hts_callbackarg *carg, httrackp *opt, char* buff, const char* adr, const char* fil, const char* referer_adr, const char* referer_fil, htsblk* incoming) {
  5494.   return 1;
  5495. }
  5496. static int __cdecl htsdefault_detect(t_hts_callbackarg *carg, httrackp *opt, htsmoduleStruct* str) {
  5497.   return 0;
  5498. }
  5499. static int __cdecl htsdefault_parse(t_hts_callbackarg *carg, httrackp *opt, htsmoduleStruct* str) {
  5500.   return 0;
  5501. }
  5502.  
  5503.  
  5504. /* Default internal dummy callbacks */
  5505. const t_hts_htmlcheck_callbacks default_callbacks = {
  5506.     { htsdefault_init, NULL },
  5507.     { htsdefault_uninit, NULL },
  5508.     { htsdefault_start, NULL },
  5509.     { htsdefault_end, NULL },
  5510.     { htsdefault_chopt, NULL },
  5511.     { htsdefault_preprocesshtml, NULL },
  5512.     { htsdefault_postprocesshtml, NULL },
  5513.     { htsdefault_checkhtml, NULL },
  5514.     { htsdefault_query, NULL },
  5515.     { htsdefault_query2, NULL },
  5516.     { htsdefault_query3, NULL },
  5517.     { htsdefault_loop, NULL },
  5518.     { htsdefault_check, NULL },
  5519.     { htsdefault_check_mime, NULL },
  5520.     { htsdefault_pause, NULL },
  5521.     { htsdefault_filesave, NULL },
  5522.     { htsdefault_filesave2, NULL },
  5523.     { htsdefault_linkdetected, NULL },
  5524.     { htsdefault_linkdetected2, NULL },
  5525.     { htsdefault_xfrstatus, NULL },
  5526.     { htsdefault_savename, NULL },
  5527.     { htsdefault_sendhead, NULL },
  5528.     { htsdefault_receivehead, NULL },
  5529.     { htsdefault_detect, NULL },
  5530.     { htsdefault_parse, NULL }
  5531. };
  5532.  
  5533. #define CHARCAST(A) ( (char*) (A) )
  5534. #define OFFSET_OF(TYPE, MEMBER) ( (size_t) ( CHARCAST(&(((TYPE*) NULL)->MEMBER)) - CHARCAST((TYPE*) NULL) ) )
  5535. #define CALLBACK_REF(name, fun) \
  5536.   { name, OFFSET_OF(t_hts_htmlcheck_callbacks, fun) }
  5537. #define MEMBER_OF(STRUCT, OFFSET, TYPE) ( * ((TYPE*)((char*)(STRUCT) + (OFFSET))) )
  5538.  
  5539. const t_hts_callback_ref default_callbacks_ref[] = {
  5540.     CALLBACK_REF("init", init),
  5541.     CALLBACK_REF("free", uninit),
  5542.     CALLBACK_REF("start", start),
  5543.     CALLBACK_REF("end", end),
  5544.     CALLBACK_REF("change-options", chopt),
  5545.     CALLBACK_REF("preprocess-html", preprocess),
  5546.     CALLBACK_REF("postprocess-html", postprocess),
  5547.     CALLBACK_REF("check-html", check_html),
  5548.     CALLBACK_REF("query", query),
  5549.     CALLBACK_REF("query2", query2),
  5550.     CALLBACK_REF("query3", query3),
  5551.     CALLBACK_REF("loop", loop),
  5552.     CALLBACK_REF("check-link", check_link),
  5553.     CALLBACK_REF("check-mime", check_mime),
  5554.     CALLBACK_REF("pause", pause),
  5555.     CALLBACK_REF("save-file", filesave),
  5556.     CALLBACK_REF("save-file2", filesave2),
  5557.     CALLBACK_REF("link-detected", linkdetected),
  5558.     CALLBACK_REF("link-detected2", linkdetected2),
  5559.     CALLBACK_REF("transfer-status", xfrstatus),
  5560.     CALLBACK_REF("save-name", savename),
  5561.     CALLBACK_REF("send-header", sendhead),
  5562.     CALLBACK_REF("receive-header", receivehead),
  5563.     { NULL, 0 }
  5564. };
  5565.  
  5566. size_t hts_get_callback_offs(const char *name) {
  5567.     const t_hts_callback_ref *ref;
  5568.     for(ref = &default_callbacks_ref[0] ; ref->name != NULL ; ref++) {
  5569.         if (strcmp(name, ref->name) == 0) {
  5570.             return ref->offset;
  5571.         }
  5572.     }
  5573.     return (size_t)(-1);
  5574. }
  5575.  
  5576. int hts_set_callback(t_hts_htmlcheck_callbacks *callbacks, const char *name, void *function) {
  5577.     size_t offs = hts_get_callback_offs(name);
  5578.     if (offs != (size_t) -1) {
  5579.         MEMBER_OF(callbacks, offs, void*) = function;
  5580.         return 0;
  5581.     }
  5582.     return 1;
  5583. }
  5584.  
  5585. void *hts_get_callback(t_hts_htmlcheck_callbacks *callbacks, const char *name) {
  5586.     size_t offs = hts_get_callback_offs(name);
  5587.     if (offs != (size_t) -1) {
  5588.         return MEMBER_OF(callbacks, offs, void*);
  5589.     }
  5590.     return NULL;
  5591. }
  5592.  
  5593. // end defaut wrappers
  5594.  
  5595. /* libc stubs */
  5596.  
  5597. HTSEXT_API char* hts_strdup(const char* str) {
  5598.   return strdup(str);
  5599. }
  5600.  
  5601. HTSEXT_API void* hts_malloc(size_t size) {
  5602.   return malloc(size);
  5603. }
  5604.  
  5605. HTSEXT_API void* hts_realloc(void* data, size_t size) {
  5606.   return realloc(data, size);
  5607. }
  5608.  
  5609. HTSEXT_API void hts_free(void* data) {
  5610.   free(data);
  5611. }
  5612.  
  5613. /* Dummy functions */
  5614. HTSEXT_API int hts_resetvar(void) {
  5615.     return 0;
  5616. }
  5617.  
  5618. #ifdef _WIN32
  5619.  
  5620. typedef struct dirent dirent;
  5621. DIR *opendir(const char *name) {
  5622.   WIN32_FILE_ATTRIBUTE_DATA st;
  5623.   DIR *dir;
  5624.   size_t len;
  5625.   int i;
  5626.   if (name == NULL || *name == '\0') {
  5627.     errno = ENOENT;
  5628.     return NULL;
  5629.   }
  5630.   if (!GetFileAttributesEx(name, GetFileExInfoStandard, &st)
  5631.     || ( st.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) == 0) {
  5632.     errno = ENOENT;
  5633.     return NULL;
  5634.   }
  5635.   dir = calloc(sizeof(DIR), 1);
  5636.   if (dir == NULL) {
  5637.     errno = ENOMEM;
  5638.     return NULL;
  5639.   }
  5640.   len = strlen(name);
  5641.   dir->h = INVALID_HANDLE_VALUE;
  5642.   dir->name = malloc(len + 2 + 1);
  5643.   strcpy(dir->name, name);
  5644.   for(i = 0 ; dir->name[i] != '\0' ; i++) {
  5645.     if (dir->name[i] == '/') {
  5646.       dir->name[i] = '\\';
  5647.     }
  5648.   }
  5649.   strcat(dir->name, "\\*");
  5650.   return dir;
  5651. }
  5652.  
  5653. struct dirent *readdir(DIR *dir) {
  5654.   WIN32_FIND_DATAA find;
  5655.   if (dir->h == INVALID_HANDLE_VALUE) {
  5656.     dir->h = FindFirstFileA(dir->name, &find);
  5657.   } else {
  5658.     if (!FindNextFile(dir->h, &find)) {
  5659.       FindClose(dir->h);
  5660.       dir->h = INVALID_HANDLE_VALUE;
  5661.     }
  5662.   }
  5663.   if (dir->h != INVALID_HANDLE_VALUE) {
  5664.     dir->entry.d_name[0] = 0;
  5665.     strncat(dir->entry.d_name, find.cFileName, HTS_DIRENT_SIZE - 1);
  5666.     return &dir->entry;
  5667.   }
  5668.   errno = ENOENT;
  5669.   return NULL;
  5670. }
  5671.  
  5672. int closedir(DIR *dir) {
  5673.   if (dir != NULL) {
  5674.     if (dir->h != INVALID_HANDLE_VALUE) {
  5675.       CloseHandle(dir->h);
  5676.     }
  5677.     if (dir->name != NULL) {
  5678.       free(dir->name);
  5679.     }
  5680.     free(dir);
  5681.     return 0;
  5682.   }
  5683.   errno = EBADF;
  5684.   return -1;
  5685. }
  5686. #endif
  5687.  
  5688. // Fin
  5689.  
  5690.